Multi-tile architecture for graphics operations

ABSTRACT

Embodiments are generally directed to a multi-tile architecture for graphics operations. An embodiment of an apparatus includes a multi-tile architecture for graphics operations including a multi-tile graphics processor, the multi-tile processor includes one or more dies; multiple processor tiles installed on the one or more dies; and a structure to interconnect the processor tiles on the one or more dies, wherein the structure to enable communications between processor tiles the processor tiles.

CLAIM OF PRIORITY/CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims, under 35 U.S.C. § 371, the benefit of andpriority to International Application No. PCT/US2020/022848, filed Mar.14, 2020, entitled MULTI-TILE ARCHITECTURE FOR GRAPHICS OPERATIONS, theentire content of which is incorporated herein by reference.International Application No. PCT/US2020/022848 is related to and, under35 U.S.C. 119(e), claims the benefit of and priority to U.S. ProvisionalApplications 62/819,337, entitled GRAPHICS PROCESSING, by Abhishek Appu,et al., filed Mar. 15, 2019 (Attorney Docket No. AC0271-Z), 62/819,435,entitled GRAPHICS DATA PROCESSING, by Lakshminarayanan Striramassarma,et al., filed Mar. 15, 2019 (Attorney Docket No. AC0285-Z), and62/819,361, entitled SYSTEMS AND METHODS FOR PARTITIONING CACHE TOREDUCE CACHE ACCESS LATENCY, by Subramaniam Maiyuran, et al., filed Mar.15, 2019 (Attorney Docket No. AC0286-Z), the contents of all areincorporated herein by reference.

TECHNICAL FIELD

Embodiments described herein generally relate to the field of electronicdevices and, more particularly, a multi-tile architecture for graphicsoperations.

BACKGROUND

Current parallel graphics data processing includes systems and methodsdeveloped to perform specific operations on graphics data such as, forexample, linear interpolation, tessellation, rasterization, texturemapping, depth testing, etc. Traditionally, graphics processors usedfixed function computational units to process graphics data; however,more recently, portions of graphics processors have been madeprogrammable, enabling such processors to support a wider variety ofoperations for processing vertex and fragment data.

To further increase performance, graphics processors typically implementprocessing techniques such as pipelining that attempt to process, inparallel, as much graphics data as possible throughout the differentparts of the graphics pipeline. Parallel graphics processors with singleinstruction, multiple thread (SIMT) architectures are designed tomaximize the amount of parallel processing in the graphics pipeline. Inan SIMT architecture, groups of parallel threads attempt to executeprogram instructions synchronously together as often as possible toincrease processing efficiency. A general overview of software andhardware for SIMT architectures can be found in Shane Cook, CUDAProgramming Chapter 3, pages 37-51 (2013).

In the development of new graphics processors, a processor such as agraphics processing unit (GPU) may be designed to include multiple tiles(which may also be referred to as chiplets) rather than a singlecomputer die. However, conventional GPU structures may not be efficientin terms of performance, power consumption, or tile usage.

BRIEF DESCRIPTION OF THE DRAWINGS

So that the manner in which the above recited features of the presentembodiments can be understood in detail, a more particular descriptionof the embodiments, briefly summarized above, may be had by reference toembodiments, some of which are illustrated in the appended drawings. Itis to be noted, however, that the appended drawings illustrate onlytypical embodiments and are therefore not to be considered limiting ofits scope.

FIG. 1 is a block diagram illustrating a computer system configured toimplement one or more aspects of the embodiments described herein;

FIG. 2A-2D illustrate parallel processor components;

FIG. 3A-3C are block diagrams of graphics multiprocessors andmultiprocessor-based GPUs;

FIG. 4A-4F illustrate an exemplary architecture in which a plurality ofGPUs is communicatively coupled to a plurality of multi-core processors;

FIG. 5 illustrates a graphics processing pipeline;

FIG. 6 illustrates a machine learning software stack;

FIG. 7 illustrates a general-purpose graphics processing unit;

FIG. 8 illustrates a multi-GPU computing system;

FIG. 9A-9B illustrate layers of exemplary deep neural networks;

FIG. 10 illustrates an exemplary recurrent neural network;

FIG. 11 illustrates training and deployment of a deep neural network;

FIG. 12 is a block diagram illustrating distributed learning;

FIG. 13 illustrates an exemplary inferencing system on a chip (SOC)suitable for performing inferencing using a trained model;

FIG. 14 is a block diagram of a processing system;

FIG. 15A-15C illustrate computing systems and graphics processors;

FIG. 16A-16C illustrate block diagrams of additional graphics processorand compute accelerator architectures;

FIG. 17 is a block diagram of a graphics processing engine of a graphicsprocessor;

FIG. 18A-18B illustrate thread execution logic including an array ofprocessing elements employed in a graphics processor core;

FIG. 19 illustrates an additional execution unit;

FIG. 20 is a block diagram illustrating a graphics processor instructionformats;

FIG. 21 is a block diagram of an additional graphics processorarchitecture;

FIG. 22A-22B illustrate a graphics processor command format and commandsequence;

FIG. 23 illustrates exemplary graphics software architecture for a dataprocessing system;

FIG. 24A is a block diagram illustrating an IP core development system;

FIG. 24B illustrates a cross-section side view of an integrated circuitpackage assembly;

FIG. 24C illustrates a package assembly that includes multiple units ofhardware logic chiplets connected to a substrate (e.g., base die);

FIG. 24D illustrates a package assembly including interchangeablechiplets;

FIG. 25 is a block diagram illustrating an exemplary system on a chipintegrated circuit;

FIG. 26A-26B are block diagrams illustrating exemplary graphicsprocessors for use within an SoC;

FIG. 27A is an illustration tile connectivity in a multi-tile GPUutilizing serial or parallel links in a die, according to someembodiments;

FIG. 27B is an illustration of tile connectivity in a multi-tile GPUutilizing architectural sharing of physical pins or wires between tiles,according to some embodiments;

FIG. 28 is an illustration of tile connectivity in a multi-tile GPUutilizing a tile sub-cluster architecture, according to someembodiments;

FIG. 29 is an illustration of asymmetric tile construction for amulti-tile GPU, according to some embodiments;

FIG. 30 is an illustration of asymmetrical multi-tile architecture,according to some embodiments;

FIG. 31 is a flow chart for a process for selecting and fabricatingtiles for a multi-tile GPU, according to some embodiments;

FIG. 32 is an illustration of an apparatus or system for dynamicexclusive assignment of cores to fixed function units in a GPU,according to some embodiments; and

FIG. 33 is an illustration of a process for dynamic exclusive assignmentof cores to fixed function units in a GPU, according to someembodiments.

DETAILED DESCRIPTION

Embodiments described herein are generally directed to a multi-tilearchitecture for graphics operations.

A multi-tile graphics processor architecture may allow an opportunity toscale three-dimensional (3D) rendering performance by having geometryhash across tiles. However, while geometry data is kept locally on thetile, the raster needs data from different tiles since geometry can bepartially of fully owned by the given tile at the raster time andlocation of actual geometry data may not be local. This interferes withscaling performance for a multi-tile graphics processor.

In some embodiments, an apparatus, system, or process provides for oneor more of:

(1) Tile Connectivity Enhancements for a Multi-Tile GPU;

(2) Asymmetrical Multi-Tile GPU Architecture; and

(3) Dynamic Exclusive Assignment of Fixed Functions to Cores.

A graphics processing unit (GPU) is communicatively coupled tohost/processor cores to accelerate, for example, graphics operations,machine-learning operations, pattern analysis operations, and/or variousgeneral-purpose GPU (GPGPU) functions. The GPU may be communicativelycoupled to the host processor/cores over a bus or another interconnect(e.g., a high-speed interconnect such as PCIe or NVLink). Alternatively,the GPU may be integrated on the same package or chip as the cores andcommunicatively coupled to the cores over an internal processorbus/interconnect (i.e., internal to the package or chip). Regardless ofthe manner in which the GPU is connected, the processor cores mayallocate work to the GPU in the form of sequences ofcommands/instructions contained in a work descriptor. The GPU then usesdedicated circuitry/logic for efficiently processing thesecommands/instructions.

In the following description, numerous specific details are set forth toprovide a more thorough understanding. However, will be apparent one ofskill in the art that the embodiments described herein may be practicedwithout one or more of these specific detail. In other instances,well-known features have not been described to avoid obscuring thedetails of the present embodiments.

System Overview

FIG. 1 is a block diagram illustrating a computing system 100 configuredto implement one or more aspects of the embodiments described herein.The computing system 100 includes a processing subsystem 101 having oneor more processor(s) 102 and a system memory 104 communicating via aninterconnection path that may include a memory hub 105. The memory hub105 may be a separate component within a chipset component or may beintegrated within the one or more processor(s) 102. The memory hub 105couples with an I/O subsystem 111 via a communication link 106. The I/Osubsystem 111 includes an I/O hub 107 that can enable the computingsystem 100 to receive input from one or more input device(s) 108.Additionally, the I/O hub 107 can enable a display controller, which maybe included in the one or more processor(s) 102, to provide outputs toone or more display device(s) 110A. In one embodiment the one or moredisplay device(s) 110A coupled with the I/O hub 107 can include a local,internal, or embedded display device.

The processing subsystem 101, for example, includes one or more parallelprocessor(s) 112 coupled to memory hub 105 via a bus or othercommunication link 113. The communication link 113 may be one of anynumber of standards-based communication link technologies or protocols,such as, but not limited to PCI Express, or may be a vendor specificcommunications interface or communications fabric. The one or moreparallel processor(s) 112 may form a computationally focused parallel orvector processing system that can include a large number of processingcores and/or processing clusters, such as a many integrated core (MIC)processor. For example, the one or more parallel processor(s) 112 form agraphics processing subsystem that can output pixels to one of the oneor more display device(s) 110A coupled via the I/O Hub 107. The one ormore parallel processor(s) 112 can also include a display controller anddisplay interface (not shown) to enable a direct connection to one ormore display device(s) 110B.

Within the I/O subsystem 111, a system storage unit 114 can connect tothe I/O hub 107 to provide a storage mechanism for the computing system100. An I/O switch 116 can be used to provide an interface mechanism toenable connections between the I/O hub 107 and other components, such asa network adapter 118 and/or wireless network adapter 119 that may beintegrated into the platform, and various other devices that can beadded via one or more add-in device(s) 120. The add-in device(s) 120 mayalso include, for example, one or more external graphics processordevices and/or compute accelerators. The network adapter 118 can be anEthernet adapter or another wired network adapter. The wireless networkadapter 119 can include one or more of a Wi-Fi, Bluetooth, near fieldcommunication (NFC), or other network device that includes one or morewireless radios.

The computing system 100 can include other components not explicitlyshown, including USB or other port connections, optical storage drives,video capture devices, and the like, may also be connected to the I/Ohub 107. Communication paths interconnecting the various components inFIG. 1 may be implemented using any suitable protocols, such as PCI(Peripheral Component Interconnect) based protocols (e.g., PCI-Express),or any other bus or point-to-point communication interfaces and/orprotocol(s), such as the NVLink high-speed interconnect, or interconnectprotocols known in the art.

The one or more parallel processor(s) 112 may incorporate circuitryoptimized for graphics and video processing, including, for example,video output circuitry, and constitutes a graphics processing unit(GPU). Alternatively or additionally, the one or more parallelprocessor(s) 112 can incorporate circuitry optimized for general purposeprocessing, while preserving the underlying computational architecture,described in greater detail herein. Components of the computing system100 may be integrated with one or more other system elements on a singleintegrated circuit. For example, the one or more parallel processor(s)112, memory hub 105, processor(s) 102, and I/O hub 107 can be integratedinto a system on chip (SoC) integrated circuit. Alternatively, thecomponents of the computing system 100 can be integrated into a singlepackage to form a system in package (SIP) configuration. In oneembodiment at least a portion of the components of the computing system100 can be integrated into a multi-chip module (MCM), which can beinterconnected with other multi-chip modules into a modular computingsystem.

It will be appreciated that the computing system 100 shown herein isillustrative and that variations and modifications are possible. Theconnection topology, including the number and arrangement of bridges,the number of processor(s) 102, and the number of parallel processor(s)112, may be modified as desired. For instance, system memory 104 can beconnected to the processor(s) 102 directly rather than through a bridge,while other devices communicate with system memory 104 via the memoryhub 105 and the processor(s) 102. In other alternative topologies, theparallel processor(s) 112 are connected to the I/O hub 107 or directlyto one of the one or more processor(s) 102, rather than to the memoryhub 105. In other embodiments, the I/O hub 107 and memory hub 105 may beintegrated into a single chip. It is also possible that two or more setsof processor(s) 102 are attached via multiple sockets, which can couplewith two or more instances of the parallel processor(s) 112.

Some of the particular components shown herein are optional and may notbe included in all implementations of the computing system 100. Forexample, any number of add-in cards or peripherals may be supported, orsome components may be eliminated. Furthermore, some architectures mayuse different terminology for components similar to those illustrated inFIG. 1. For example, the memory hub 105 may be referred to as aNorthbridge in some architectures, while the I/O hub 107 may be referredto as a Southbridge.

FIG. 2A illustrates a parallel processor 200. The parallel processor 200may be a GPU, GPGPU or the like as described herein. The variouscomponents of the parallel processor 200 may be implemented using one ormore integrated circuit devices, such as programmable processors,application specific integrated circuits (ASICs), or field programmablegate arrays (FPGA). The illustrated parallel processor 200 may be the,or one of the parallel processor(s) 112 shown in FIG. 1.

The parallel processor 200 includes a parallel processing unit 202. Theparallel processing unit includes an I/O unit 204 that enablescommunication with other devices, including other instances of theparallel processing unit 202. The I/O unit 204 may be directly connectedto other devices. For instance, the I/O unit 204 connects with otherdevices via the use of a hub or switch interface, such as memory hub105. The connections between the memory hub 105 and the I/O unit 204form a communication link 113. Within the parallel processing unit 202,the I/O unit 204 connects with a host interface 206 and a memorycrossbar 216, where the host interface 206 receives commands directed toperforming processing operations and the memory crossbar 216 receivescommands directed to performing memory operations.

When the host interface 206 receives a command buffer via the I/O unit204, the host interface 206 can direct work operations to perform thosecommands to a front end 208. In one embodiment the front end 208 coupleswith a scheduler 210, which is configured to distribute commands orother work items to a processing cluster array 212. The scheduler 210ensures that the processing cluster array 212 is properly configured andin a valid state before tasks are distributed to the processing clustersof the processing cluster array 212. The scheduler 210 may beimplemented via firmware logic executing on a microcontroller. Themicrocontroller implemented scheduler 210 is configurable to performcomplex scheduling and work distribution operations at coarse and finegranularity, enabling rapid preemption and context switching of threadsexecuting on the processing array 212. Preferably, the host software canprove workloads for scheduling on the processing array 212 via one ofmultiple graphics processing doorbells. The workloads can then beautomatically distributed across the processing array 212 by thescheduler 210 logic within the scheduler microcontroller.

The processing cluster array 212 can include up to “N” processingclusters (e.g., cluster 214A, cluster 214B, through cluster 214N). Eachcluster 214A-214N of the processing cluster array 212 can execute alarge number of concurrent threads. The scheduler 210 can allocate workto the clusters 214A-214N of the processing cluster array 212 usingvarious scheduling and/or work distribution algorithms, which may varydepending on the workload arising for each type of program orcomputation. The scheduling can be handled dynamically by the scheduler210, or can be assisted in part by compiler logic during compilation ofprogram logic configured for execution by the processing cluster array212. Optionally, different clusters 214A-214N of the processing clusterarray 212 can be allocated for processing different types of programs orfor performing different types of computations.

The processing cluster array 212 can be configured to perform varioustypes of parallel processing operations. For example, the cluster array212 is configured to perform general-purpose parallel computeoperations. For example, the processing cluster array 212 can includelogic to execute processing tasks including filtering of video and/oraudio data, performing modeling operations, including physicsoperations, and performing data transformations.

The processing cluster array 212 is configured to perform parallelgraphics processing operations. In such embodiments in which theparallel processor 200 is configured to perform graphics processingoperations, the processing cluster array 212 can include additionallogic to support the execution of such graphics processing operations,including, but not limited to texture sampling logic to perform textureoperations, as well as tessellation logic and other vertex processinglogic. Additionally, the processing cluster array 212 can be configuredto execute graphics processing related shader programs such as, but notlimited to vertex shaders, tessellation shaders, geometry shaders, andpixel shaders. The parallel processing unit 202 can transfer data fromsystem memory via the I/O unit 204 for processing. During processing thetransferred data can be stored to on-chip memory (e.g., parallelprocessor memory 222) during processing, then written back to systemmemory.

In embodiments in which the parallel processing unit 202 is used toperform graphics processing, the scheduler 210 may be configured todivide the processing workload into approximately equal sized tasks, tobetter enable distribution of the graphics processing operations tomultiple clusters 214A-214N of the processing cluster array 212. In someof these embodiments, portions of the processing cluster array 212 canbe configured to perform different types of processing. For example afirst portion may be configured to perform vertex shading and topologygeneration, a second portion may be configured to perform tessellationand geometry shading, and a third portion may be configured to performpixel shading or other screen space operations, to produce a renderedimage for display. Intermediate data produced by one or more of theclusters 214A-214N may be stored in buffers to allow the intermediatedata to be transmitted between clusters 214A-214N for furtherprocessing.

During operation, the processing cluster array 212 can receiveprocessing tasks to be executed via the scheduler 210, which receivescommands defining processing tasks from front end 208. For graphicsprocessing operations, processing tasks can include indices of data tobe processed, e.g., surface (patch) data, primitive data, vertex data,and/or pixel data, as well as state parameters and commands defining howthe data is to be processed (e.g., what program is to be executed). Thescheduler 210 may be configured to fetch the indices corresponding tothe tasks or may receive the indices from the front end 208. The frontend 208 can be configured to ensure the processing cluster array 212 isconfigured to a valid state before the workload specified by incomingcommand buffers (e.g., batch-buffers, push buffers, etc.) is initiated.

Each of the one or more instances of the parallel processing unit 202can couple with parallel processor memory 222. The parallel processormemory 222 can be accessed via the memory crossbar 216, which canreceive memory requests from the processing cluster array 212 as well asthe I/O unit 204. The memory crossbar 216 can access the parallelprocessor memory 222 via a memory interface 218. The memory interface218 can include multiple partition units (e.g., partition unit 220A,partition unit 220B, through partition unit 220N) that can each coupleto a portion (e.g., memory unit) of parallel processor memory 222. Thenumber of partition units 220A-220N may be configured to be equal to thenumber of memory units, such that a first partition unit 220A has acorresponding first memory unit 224A, a second partition unit 220B has acorresponding memory unit 224B, and an Nth partition unit 220N has acorresponding Nth memory unit 224N. In other embodiments, the number ofpartition units 220A-220N may not be equal to the number of memorydevices.

The memory units 224A-224N can include various types of memory devices,including dynamic random-access memory (DRAM) or graphics random accessmemory, such as synchronous graphics random access memory (SGRAM),including graphics double data rate (GDDR) memory. Optionally, thememory units 224A-224N may also include 3D stacked memory, including butnot limited to high bandwidth memory (HBM). Persons skilled in the artwill appreciate that the specific implementation of the memory units224A-224N can vary, and can be selected from one of various conventionaldesigns. Render targets, such as frame buffers or texture maps may bestored across the memory units 224A-224N, allowing partition units220A-220N to write portions of each render target in parallel toefficiently use the available bandwidth of parallel processor memory222. In some embodiments, a local instance of the parallel processormemory 222 may be excluded in favor of a unified memory design thatutilizes system memory in conjunction with local cache memory.

Optionally, any one of the clusters 214A-214N of the processing clusterarray 212 has the ability to process data that will be written to any ofthe memory units 224A-224N within parallel processor memory 222. Thememory crossbar 216 can be configured to transfer the output of eachcluster 214A-214N to any partition unit 220A-220N or to another cluster214A-214N, which can perform additional processing operations on theoutput. Each cluster 214A-214N can communicate with the memory interface218 through the memory crossbar 216 to read from or write to variousexternal memory devices. In one of the embodiments with the memorycrossbar 216 the memory crossbar 216 has a connection to the memoryinterface 218 to communicate with the I/O unit 204, as well as aconnection to a local instance of the parallel processor memory 222,enabling the processing units within the different processing clusters214A-214N to communicate with system memory or other memory that is notlocal to the parallel processing unit 202. Generally, the memorycrossbar 216 may, for example, by able to use virtual channels toseparate traffic streams between the clusters 214A-214N and thepartition units 220A-220N.

While a single instance of the parallel processing unit 202 isillustrated within the parallel processor 200, any number of instancesof the parallel processing unit 202 can be included. For example,multiple instances of the parallel processing unit 202 can be providedon a single add-in card, or multiple add-in cards can be interconnected.The different instances of the parallel processing unit 202 can beconfigured to inter-operate even if the different instances havedifferent numbers of processing cores, different amounts of localparallel processor memory, and/or other configuration differences.Optionally, some instances of the parallel processing unit 202 caninclude higher precision floating point units relative to otherinstances. Systems incorporating one or more instances of the parallelprocessing unit 202 or the parallel processor 200 can be implemented ina variety of configurations and form factors, including but not limitedto desktop, laptop, or handheld personal computers, servers,workstations, game consoles, and/or embedded systems.

FIG. 2B is a block diagram of a partition unit 220. The partition unit220 may be an instance of one of the partition units 220A-220N of FIG.2A. As illustrated, the partition unit 220 includes an L2 cache 221, aframe buffer interface 225, and a ROP 226 (raster operations unit). TheL2 cache 221 is a read/write cache that is configured to perform loadand store operations received from the memory crossbar 216 and ROP 226.Read misses and urgent write-back requests are output by L2 cache 221 toframe buffer interface 225 for processing. Updates can also be sent tothe frame buffer via the frame buffer interface 225 for processing. Inone embodiment the frame buffer interface 225 interfaces with one of thememory units in parallel processor memory, such as the memory units224A-224N of FIG. 2A (e.g., within parallel processor memory 222). Thepartition unit 220 may additionally or alternatively also interface withone of the memory units in parallel processor memory via a memorycontroller (not shown).

In graphics applications, the ROP 226 is a processing unit that performsraster operations such as stencil, z test, blending, and the like. TheROP 226 then outputs processed graphics data that is stored in graphicsmemory. In some embodiments the ROP 226 includes compression logic tocompress depth or color data that is written to memory and decompressdepth or color data that is read from memory. The compression logic canbe lossless compression logic that makes use of one or more of multiplecompression algorithms. The type of compression that is performed by theROP 226 can vary based on the statistical characteristics of the data tobe compressed. For example, in one embodiment, delta color compressionis performed on depth and color data on a per-tile basis.

The ROP 226 may be included within each processing cluster (e.g.,cluster 214A-214N of FIG. 2A) instead of within the partition unit 220.In such embodiment, read and write requests for pixel data aretransmitted over the memory crossbar 216 instead of pixel fragment data.The processed graphics data may be displayed on a display device, suchas one of the one or more display device(s) 110 of FIG. 1, routed forfurther processing by the processor(s) 102, or routed for furtherprocessing by one of the processing entities within the parallelprocessor 200 of FIG. 2A.

FIG. 2C is a block diagram of a processing cluster 214 within a parallelprocessing unit. For example, the processing cluster is an instance ofone of the processing clusters 214A-214N of FIG. 2A. The processingcluster 214 can be configured to execute many threads in parallel, wherethe term “thread” refers to an instance of a particular programexecuting on a particular set of input data. Optionally,single-instruction, multiple-data (SIMD) instruction issue techniquesmay be used to support parallel execution of a large number of threadswithout providing multiple independent instruction units. Alternatively,single-instruction, multiple-thread (SIMT) techniques may be used tosupport parallel execution of a large number of generally synchronizedthreads, using a common instruction unit configured to issueinstructions to a set of processing engines within each one of theprocessing clusters. Unlike a SIMD execution regime, where allprocessing engines typically execute identical instructions, SIMTexecution allows different threads to more readily follow divergentexecution paths through a given thread program. Persons skilled in theart will understand that a SIMD processing regime represents afunctional subset of a SIMT processing regime.

Operation of the processing cluster 214 can be controlled via a pipelinemanager 232 that distributes processing tasks to SIMT parallelprocessors. The pipeline manager 232 receives instructions from thescheduler 210 of FIG. 2A and manages execution of those instructions viaa graphics multiprocessor 234 and/or a texture unit 236. The illustratedgraphics multiprocessor 234 is an exemplary instance of a SIMT parallelprocessor. However, various types of SIMT parallel processors ofdiffering architectures may be included within the processing cluster214. One or more instances of the graphics multiprocessor 234 can beincluded within a processing cluster 214. The graphics multiprocessor234 can process data and a data crossbar 240 can be used to distributethe processed data to one of multiple possible destinations, includingother shader units. The pipeline manager 232 can facilitate thedistribution of processed data by specifying destinations for processeddata to be distributed via the data crossbar 240.

Each graphics multiprocessor 234 within the processing cluster 214 caninclude an identical set of functional execution logic (e.g., arithmeticlogic units, load-store units, etc.). The functional execution logic canbe configured in a pipelined manner in which new instructions can beissued before previous instructions are complete. The functionalexecution logic supports a variety of operations including integer andfloating-point arithmetic, comparison operations, Boolean operations,bit-shifting, and computation of various algebraic functions. The samefunctional-unit hardware could be leveraged to perform differentoperations and any combination of functional units may be present.

The instructions transmitted to the processing cluster 214 constitutes athread. A set of threads executing across the set of parallel processingengines is a thread group. A thread group executes the same program ondifferent input data. Each thread within a thread group can be assignedto a different processing engine within a graphics multiprocessor 234. Athread group may include fewer threads than the number of processingengines within the graphics multiprocessor 234. When a thread groupincludes fewer threads than the number of processing engines, one ormore of the processing engines may be idle during cycles in which thatthread group is being processed. A thread group may also include morethreads than the number of processing engines within the graphicsmultiprocessor 234. When the thread group includes more threads than thenumber of processing engines within the graphics multiprocessor 234,processing can be performed over consecutive clock cycles. Optionally,multiple thread groups can be executed concurrently on the graphicsmultiprocessor 234.

The graphics multiprocessor 234 may include an internal cache memory toperform load and store operations. Optionally, the graphicsmultiprocessor 234 can forego an internal cache and use a cache memory(e.g., L1 cache 248) within the processing cluster 214. Each graphicsmultiprocessor 234 also has access to L2 caches within the partitionunits (e.g., partition units 220A-220N of FIG. 2A) that are shared amongall processing clusters 214 and may be used to transfer data betweenthreads. The graphics multiprocessor 234 may also access off-chip globalmemory, which can include one or more of local parallel processor memoryand/or system memory. Any memory external to the parallel processingunit 202 may be used as global memory. Embodiments in which theprocessing cluster 214 includes multiple instances of the graphicsmultiprocessor 234 can share common instructions and data, which may bestored in the L1 cache 248.

Each processing cluster 214 may include an MMU 245 (memory managementunit) that is configured to map virtual addresses into physicaladdresses. In other embodiments, one or more instances of the MMU 245may reside within the memory interface 218 of FIG. 2A. The MMU 245includes a set of page table entries (PTEs) used to map a virtualaddress to a physical address of a tile and optionally a cache lineindex. The MMU 245 may include address translation lookaside buffers(TLB) or caches that may reside within the graphics multiprocessor 234or the L1 cache or processing cluster 214. The physical address isprocessed to distribute surface data access locality to allow efficientrequest interleaving among partition units. The cache line index may beused to determine whether a request for a cache line is a hit or miss.

In graphics and computing applications, a processing cluster 214 may beconfigured such that each graphics multiprocessor 234 is coupled to atexture unit 236 for performing texture mapping operations, e.g.,determining texture sample positions, reading texture data, andfiltering the texture data. Texture data is read from an internaltexture L1 cache (not shown) or in some embodiments from the L1 cachewithin graphics multiprocessor 234 and is fetched from an L2 cache,local parallel processor memory, or system memory, as needed. Eachgraphics multiprocessor 234 outputs processed tasks to the data crossbar240 to provide the processed task to another processing cluster 214 forfurther processing or to store the processed task in an L2 cache, localparallel processor memory, or system memory via the memory crossbar 216.A preROP 242 (pre-raster operations unit) is configured to receive datafrom graphics multiprocessor 234, direct data to ROP units, which may belocated with partition units as described herein (e.g., partition units220A-220N of FIG. 2A). The preROP 242 unit can perform optimizations forcolor blending, organize pixel color data, and perform addresstranslations.

It will be appreciated that the core architecture described herein isillustrative and that variations and modifications are possible. Anynumber of processing units, e.g., graphics multiprocessor 234, textureunits 236, preROPs 242, etc., may be included within a processingcluster 214. Further, while only one processing cluster 214 is shown, aparallel processing unit as described herein may include any number ofinstances of the processing cluster 214. Optionally, each processingcluster 214 can be configured to operate independently of otherprocessing clusters 214 using separate and distinct processing units, L1caches, etc.

FIG. 2D shows an example of the graphics multiprocessor 234 in which thegraphics multiprocessor 234 couples with the pipeline manager 232 of theprocessing cluster 214. The graphics multiprocessor 234 has an executionpipeline including but not limited to an instruction cache 252, aninstruction unit 254, an address mapping unit 256, a register file 258,one or more general purpose graphics processing unit (GPGPU) cores 262,and one or more load/store units 266. The GPGPU cores 262 and load/storeunits 266 are coupled with cache memory 272 and shared memory 270 via amemory and cache interconnect 268. The graphics multiprocessor 234 mayadditionally include tensor and/or ray-tracing cores 263 that includehardware logic to accelerate matrix and/or ray-tracing operations.

The instruction cache 252 may receive a stream of instructions toexecute from the pipeline manager 232. The instructions are cached inthe instruction cache 252 and dispatched for execution by theinstruction unit 254. The instruction unit 254 can dispatch instructionsas thread groups (e.g., warps), with each thread of the thread groupassigned to a different execution unit within GPGPU core 262. Aninstruction can access any of a local, shared, or global address spaceby specifying an address within a unified address space. The addressmapping unit 256 can be used to translate addresses in the unifiedaddress space into a distinct memory address that can be accessed by theload/store units 266.

The register file 258 provides a set of registers for the functionalunits of the graphics multiprocessor 234. The register file 258 providestemporary storage for operands connected to the data paths of thefunctional units (e.g., GPGPU cores 262, load/store units 266) of thegraphics multiprocessor 234. The register file 258 may be dividedbetween each of the functional units such that each functional unit isallocated a dedicated portion of the register file 258. For example, theregister file 258 may be divided between the different warps beingexecuted by the graphics multiprocessor 234.

The GPGPU cores 262 can each include floating point units (FPUs) and/orinteger arithmetic logic units (ALUs) that are used to executeinstructions of the graphics multiprocessor 234. In someimplementations, the GPGPU cores 262 can include hardware logic that mayotherwise reside within the tensor and/or ray-tracing cores 263. TheGPGPU cores 262 can be similar in architecture or can differ inarchitecture. For example and in one embodiment, a first portion of theGPGPU cores 262 include a single precision FPU and an integer ALU whilea second portion of the GPGPU cores include a double precision FPU.Optionally, the FPUs can implement the IEEE 754-2008 standard forfloating point arithmetic or enable variable precision floating pointarithmetic. The graphics multiprocessor 234 can additionally include oneor more fixed function or special function units to perform specificfunctions such as copy rectangle or pixel blending operations. One ormore of the GPGPU cores can also include fixed or special functionlogic.

The GPGPU cores 262 may include SIMD logic capable of performing asingle instruction on multiple sets of data. Optionally, GPGPU cores 262can physically execute SIMD4, SIMD8, and SIMD16 instructions andlogically execute SIMD1, SIMD2, and SIMD32 instructions. The SIMDinstructions for the GPGPU cores can be generated at compile time by ashader compiler or automatically generated when executing programswritten and compiled for single program multiple data (SPMD) or SIMTarchitectures. Multiple threads of a program configured for the SIMTexecution model can be executed via a single SIMD instruction. Forexample and in one embodiment, eight SIMT threads that perform the sameor similar operations can be executed in parallel via a single SIMD8logic unit.

The memory and cache interconnect 268 is an interconnect network thatconnects each of the functional units of the graphics multiprocessor 234to the register file 258 and to the shared memory 270. For example, thememory and cache interconnect 268 is a crossbar interconnect that allowsthe load/store unit 266 to implement load and store operations betweenthe shared memory 270 and the register file 258. The register file 258can operate at the same frequency as the GPGPU cores 262, thus datatransfer between the GPGPU cores 262 and the register file 258 is verylow latency. The shared memory 270 can be used to enable communicationbetween threads that execute on the functional units within the graphicsmultiprocessor 234. The cache memory 272 can be used as a data cache forexample, to cache texture data communicated between the functional unitsand the texture unit 236. The shared memory 270 can also be used as aprogram managed cached. Threads executing on the GPGPU cores 262 canprogrammatically store data within the shared memory in addition to theautomatically cached data that is stored within the cache memory 272.

FIG. 3A-3C illustrate additional graphics multiprocessors, according toembodiments. FIG. 3A-3B illustrate graphics multiprocessors 325, 350,which are related to the graphics multiprocessor 234 of FIG. 2C and maybe used in place of one of those. Therefore, the disclosure of anyfeatures in combination with the graphics multiprocessor 234 herein alsodiscloses a corresponding combination with the graphicsmultiprocessor(s) 325, 350, but is not limited to such. FIG. 3Cillustrates a graphics processing unit (GPU) 380 which includesdedicated sets of graphics processing resources arranged into multi-coregroups 365A-365N, which correspond to the graphics multiprocessors 325,350. The illustrated graphics multiprocessors 325, 350 and themulti-core groups 365A-365N can be streaming multiprocessors (SM)capable of simultaneous execution of a large number of executionthreads.

The graphics multiprocessor 325 of FIG. 3A includes multiple additionalinstances of execution resource units relative to the graphicsmultiprocessor 234 of FIG. 2D. For example, the graphics multiprocessor325 can include multiple instances of the instruction unit 332A-332B,register file 334A-334B, and texture unit(s) 344A-344B. The graphicsmultiprocessor 325 also includes multiple sets of graphics or computeexecution units (e.g., GPGPU core 336A-336B, tensor core 337A-337B,ray-tracing core 338A-338B) and multiple sets of load/store units340A-340B. The execution resource units have a common instruction cache330, texture and/or data cache memory 342, and shared memory 346.

The various components can communicate via an interconnect fabric 327.The interconnect fabric 327 may include one or more crossbar switches toenable communication between the various components of the graphicsmultiprocessor 325. The interconnect fabric 327 may be a separate,high-speed network fabric layer upon which each component of thegraphics multiprocessor 325 is stacked. The components of the graphicsmultiprocessor 325 communicate with remote components via theinterconnect fabric 327. For example, the GPGPU cores 336A-336B,337A-337B, and 3378A-338B can each communicate with shared memory 346via the interconnect fabric 327. The interconnect fabric 327 canarbitrate communication within the graphics multiprocessor 325 to ensurea fair bandwidth allocation between components.

The graphics multiprocessor 350 of FIG. 3B includes multiple sets ofexecution resources 356A-356D, where each set of execution resourceincludes multiple instruction units, register files, GPGPU cores, andload store units, as illustrated in FIG. 2D and FIG. 3A. The executionresources 356A-356D can work in concert with texture unit(s) 360A-360Dfor texture operations, while sharing an instruction cache 354, andshared memory 353. For example, the execution resources 356A-356D canshare an instruction cache 354 and shared memory 353, as well asmultiple instances of a texture and/or data cache memory 358A-358B. Thevarious components can communicate via an interconnect fabric 352similar to the interconnect fabric 327 of FIG. 3A.

Persons skilled in the art will understand that the architecturedescribed in FIGS. 1, 2A-2D, and 3A-3B are descriptive and not limitingas to the scope of the present embodiments. Thus, the techniquesdescribed herein may be implemented on any properly configuredprocessing unit, including, without limitation, one or more mobileapplication processors, one or more desktop or server central processingunits (CPUs) including multi-core CPUs, one or more parallel processingunits, such as the parallel processing unit 202 of FIG. 2A, as well asone or more graphics processors or special purpose processing units,without departure from the scope of the embodiments described herein.

The parallel processor or GPGPU as described herein may becommunicatively coupled to host/processor cores to accelerate graphicsoperations, machine-learning operations, pattern analysis operations,and various general-purpose GPU (GPGPU) functions. The GPU may becommunicatively coupled to the host processor/cores over a bus or otherinterconnect (e.g., a high-speed interconnect such as PCIe or NVLink).In other embodiments, the GPU may be integrated on the same package orchip as the cores and communicatively coupled to the cores over aninternal processor bus/interconnect (i.e., internal to the package orchip). Regardless of the manner in which the GPU is connected, theprocessor cores may allocate work to the GPU in the form of sequences ofcommands/instructions contained in a work descriptor. The GPU then usesdedicated circuitry/logic for efficiently processing thesecommands/instructions.

FIG. 3C illustrates a graphics processing unit (GPU) 380 which includesdedicated sets of graphics processing resources arranged into multi-coregroups 365A-365N. While the details of only a single multi-core group365A are provided, it will be appreciated that the other multi-coregroups 365B-365N may be equipped with the same or similar sets ofgraphics processing resources. Details described with respect to themulti-core groups 365A-365N may also apply to any graphicsmultiprocessor 234, 325, 350 described herein.

As illustrated, a multi-core group 365A may include a set of graphicscores 370, a set of tensor cores 371, and a set of ray tracing cores372. A scheduler/dispatcher 368 schedules and dispatches the graphicsthreads for execution on the various cores 370, 371, 372. A set ofregister files 369 store operand values used by the cores 370, 371, 372when executing the graphics threads. These may include, for example,integer registers for storing integer values, floating point registersfor storing floating point values, vector registers for storing packeddata elements (integer and/or floating-point data elements) and tileregisters for storing tensor/matrix values. The tile registers may beimplemented as combined sets of vector registers.

One or more combined level 1 (L1) caches and shared memory units 373store graphics data such as texture data, vertex data, pixel data, raydata, bounding volume data, etc., locally within each multi-core group365A. One or more texture units 374 can also be used to performtexturing operations, such as texture mapping and sampling. A Level 2(L2) cache 375 shared by all or a subset of the multi-core groups365A-365N stores graphics data and/or instructions for multipleconcurrent graphics threads. As illustrated, the L2 cache 375 may beshared across a plurality of multi-core groups 365A-365N. One or morememory controllers 367 couple the GPU 380 to a memory 366 which may be asystem memory (e.g., DRAM) and/or a dedicated graphics memory (e.g.,GDDR6 memory).

Input/output (I/O) circuitry 363 couples the GPU 380 to one or more I/Odevices 362 such as digital signal processors (DSPs), networkcontrollers, or user input devices. An on-chip interconnect may be usedto couple the I/O devices 362 to the GPU 380 and memory 366. One or moreI/O memory management units (IOMMUs) 364 of the I/O circuitry 363 couplethe I/O devices 362 directly to the system memory 366. Optionally, theIOMMU 364 manages multiple sets of page tables to map virtual addressesto physical addresses in system memory 366. The I/O devices 362, CPU(s)361, and GPU(s) 380 may then share the same virtual address space.

In one implementation of the IOMMU 364, the IOMMU 364 supportsvirtualization. In this case, it may manage a first set of page tablesto map guest/graphics virtual addresses to guest/graphics physicaladdresses and a second set of page tables to map the guest/graphicsphysical addresses to system/host physical addresses (e.g., withinsystem memory 366). The base addresses of each of the first and secondsets of page tables may be stored in control registers and swapped outon a context switch (e.g., so that the new context is provided withaccess to the relevant set of page tables). While not illustrated inFIG. 3C, each of the cores 370, 371, 372 and/or multi-core groups365A-365N may include translation lookaside buffers (TLBs) to cacheguest virtual to guest physical translations, guest physical to hostphysical translations, and guest virtual to host physical translations.

The CPUs 361, GPUs 380, and I/O devices 362 may be integrated on asingle semiconductor chip and/or chip package. The illustrated memory366 may be integrated on the same chip or may be coupled to the memorycontrollers 367 via an off-chip interface. In one implementation, thememory 366 comprises GDDR6 memory which shares the same virtual addressspace as other physical system-level memories, although the underlyingprinciples described herein are not limited to this specificimplementation.

The tensor cores 371 may include a plurality of execution unitsspecifically designed to perform matrix operations, which are thefundamental compute operation used to perform deep learning operations.For example, simultaneous matrix multiplication operations may be usedfor neural network training and inferencing. The tensor cores 371 mayperform matrix processing using a variety of operand precisionsincluding single precision floating-point (e.g., 32 bits),half-precision floating point (e.g., 16 bits), integer words (16 bits),bytes (8 bits), and half-bytes (4 bits). For example, a neural networkimplementation extracts features of each rendered scene, potentiallycombining details from multiple frames, to construct a high-qualityfinal image.

In deep learning implementations, parallel matrix multiplication workmay be scheduled for execution on the tensor cores 371. The training ofneural networks, in particular, requires a significant number matrix dotproduct operations. In order to process an inner-product formulation ofan N×N×N matrix multiply, the tensor cores 371 may include at least Ndot-product processing elements. Before the matrix multiply begins, oneentire matrix is loaded into tile registers and at least one column of asecond matrix is loaded each cycle for N cycles. Each cycle, there are Ndot products that are processed.

Matrix elements may be stored at different precisions depending on theparticular implementation, including 16-bit words, 8-bit bytes (e.g.,INT8) and 4-bit half-bytes (e.g., INT4). Different precision modes maybe specified for the tensor cores 371 to ensure that the most efficientprecision is used for different workloads (e.g., such as inferencingworkloads which can tolerate quantization to bytes and half-bytes).

The ray tracing cores 372 may accelerate ray tracing operations for bothreal-time ray tracing and non-real-time ray tracing implementations. Inparticular, the ray tracing cores 372 may include raytraversal/intersection circuitry for performing ray traversal usingbounding volume hierarchies (BVHs) and identifying intersections betweenrays and primitives enclosed within the BVH volumes. The ray tracingcores 372 may also include circuitry for performing depth testing andculling (e.g., using a Z buffer or similar arrangement). In oneimplementation, the ray tracing cores 372 perform traversal andintersection operations in concert with the image denoising techniquesdescribed herein, at least a portion of which may be executed on thetensor cores 371. For example, the tensor cores 371 may implement a deeplearning neural network to perform denoising of frames generated by theray tracing cores 372. However, the CPU(s) 361, graphics cores 370,and/or ray tracing cores 372 may also implement all or a portion of thedenoising and/or deep learning algorithms.

In addition, as described above, a distributed approach to denoising maybe employed in which the GPU 380 is in a computing device coupled toother computing devices over a network or high-speed interconnect. Inthis distributed approach, the interconnected computing devices mayshare neural network learning/training data to improve the speed withwhich the overall system learns to perform denoising for different typesof image frames and/or different graphics applications.

The ray tracing cores 372 may process all BVH traversal and/orray-primitive intersections, saving the graphics cores 370 from beingoverloaded with thousands of instructions per ray. For example, each raytracing core 372 includes a first set of specialized circuitry forperforming bounding box tests (e.g., for traversal operations) and/or asecond set of specialized circuitry for performing the ray-triangleintersection tests (e.g., intersecting rays which have been traversed).Thus, for example, the multi-core group 365A can simply launch a rayprobe, and the ray tracing cores 372 independently perform ray traversaland intersection and return hit data (e.g., a hit, no hit, multiplehits, etc.) to the thread context. The other cores 370, 371 are freed toperform other graphics or compute work while the ray tracing cores 372perform the traversal and intersection operations.

Optionally, each ray tracing core 372 may include a traversal unit toperform BVH testing operations and/or an intersection unit whichperforms ray-primitive intersection tests. The intersection unitgenerates a “hit”, “no hit”, or “multiple hit” response, which itprovides to the appropriate thread. During the traversal andintersection operations, the execution resources of the other cores(e.g., graphics cores 370 and tensor cores 371) are freed to performother forms of graphics work.

In one optional embodiment described below, a hybrid rasterization/raytracing approach is used in which work is distributed between thegraphics cores 370 and ray tracing cores 372.

The ray tracing cores 372 (and/or other cores 370, 371) may includehardware support for a ray tracing instruction set such as Microsoft'sDirectX Ray Tracing (DXR) which includes a DispatchRays command, as wellas ray-generation, closest-hit, any-hit, and miss shaders, which enablethe assignment of unique sets of shaders and textures for each object.Another ray tracing platform which may be supported by the ray tracingcores 372, graphics cores 370 and tensor cores 371 is Vulkan 1.1.85.Note, however, that the underlying principles described herein are notlimited to any particular ray tracing ISA.

In general, the various cores 372, 371, 370 may support a ray tracinginstruction set that includes instructions/functions for one or more ofray generation, closest hit, any hit, ray-primitive intersection,per-primitive and hierarchical bounding box construction, miss, visit,and exceptions. More specifically, a preferred embodiment includes raytracing instructions to perform one or more of the following functions:

Ray Generation—Ray generation instructions may be executed for eachpixel, sample, or other user-defined work assignment.

Closest Hit—A closest hit instruction may be executed to locate theclosest intersection point of a ray with primitives within a scene.

Any Hit—An any hit instruction identifies multiple intersections betweena ray and primitives within a scene, potentially to identify a newclosest intersection point.

Intersection—An intersection instruction performs a ray-primitiveintersection test and outputs a result.

Per-primitive Bounding box Construction—This instruction builds abounding box around a given primitive or group of primitives (e.g., whenbuilding a new BVH or other acceleration data structure).

Miss—Indicates that a ray misses all geometry within a scene, orspecified region of a scene.

Visit—Indicates the children volumes a ray will traverse.

Exceptions—Includes various types of exception handlers (e.g., invokedfor various error conditions).

Techniques for GPU to Host Processor Interconnection

FIG. 4A illustrates an exemplary architecture in which a plurality ofGPUs 410-413, e.g. such as the parallel processors 200 shown in FIG. 2A,are communicatively coupled to a plurality of multi-core processors405-406 over high-speed links 440A-440D (e.g., buses, point-to-pointinterconnects, etc.). The high-speed links 440A-440D may support acommunication throughput of 4 GB/s, 30 GB/s, 80 GB/s or higher,depending on the implementation. Various interconnect protocols may beused including, but not limited to, PCIe 4.0 or 5.0 and NVLink 2.0.However, the underlying principles described herein are not limited toany particular communication protocol or throughput.

Two or more of the GPUs 410-413 may be interconnected over high-speedlinks 442A-442B, which may be implemented using the same or differentprotocols/links than those used for high-speed links 440A-440D.Similarly, two or more of the multi-core processors 405-406 may beconnected over high speed link 443 which may be symmetricmulti-processor (SMP) buses operating at 20 GB/s, 30 GB/s, 120 GB/s orhigher. Alternatively, all communication between the various systemcomponents shown in FIG. 4A may be accomplished using the sameprotocols/links (e.g., over a common interconnection fabric). Asmentioned, however, the underlying principles described herein are notlimited to any particular type of interconnect technology.

Each multi-core processor 405-406 may be communicatively coupled to aprocessor memory 401-402, via memory interconnects 430A-430B,respectively, and each GPU 410-413 is communicatively coupled to GPUmemory 420-423 over GPU memory interconnects 450A-450D, respectively.The memory interconnects 430A-430B and 450A-450D may utilize the same ordifferent memory access technologies. By way of example, and notlimitation, the processor memories 401-402 and GPU memories 420-423 maybe volatile memories such as dynamic random-access memories (DRAMs)(including stacked DRAMs), Graphics DDR SDRAM (GDDR) (e.g., GDDR5,GDDR6), or High Bandwidth Memory (HBM) and/or may be non-volatilememories such as 3D XPoint/Optane or Nano-Ram. For example, some portionof the memories may be volatile memory and another portion may benon-volatile memory (e.g., using a two-level memory (2LM) hierarchy).

As described below, although the various processors 405-406 and GPUs410-413 may be physically coupled to a particular memory 401-402,420-423, respectively, a unified memory architecture may be implementedin which the same virtual system address space (also referred to as the“effective address” space) is distributed among all of the variousphysical memories. For example, processor memories 401-402 may eachcomprise 64 GB of the system memory address space and GPU memories420-423 may each comprise 32 GB of the system memory address space(resulting in a total of 256 GB addressable memory in this example).

FIG. 4B illustrates additional optional details for an interconnectionbetween a multi-core processor 407 and a graphics acceleration module446. The graphics acceleration module 446 may include one or more GPUchips integrated on a line card which is coupled to the processor 407via the high-speed link 440. Alternatively, the graphics accelerationmodule 446 may be integrated on the same package or chip as theprocessor 407.

The illustrated processor 407 includes a plurality of cores 460A-460D,each with a translation lookaside buffer 461A-461D and one or morecaches 462A-462D. The cores may include various other components forexecuting instructions and processing data which are not illustrated toavoid obscuring the underlying principles of the components describedherein (e.g., instruction fetch units, branch prediction units,decoders, execution units, reorder buffers, etc.). The caches 462A-462Dmay comprise level 1 (L1) and level 2 (L2) caches. In addition, one ormore shared caches 456 may be included in the caching hierarchy andshared by sets of the cores 460A-460D. For example, one embodiment ofthe processor 407 includes 24 cores, each with its own L1 cache, twelveshared L2 caches, and twelve shared L3 caches. In this embodiment, oneof the L2 and L3 caches are shared by two adjacent cores. The processor407 and the graphics accelerator integration module 446 connect withsystem memory 441, which may include processor memories 401-402.

Coherency is maintained for data and instructions stored in the variouscaches 462A-462D, 456 and system memory 441 via inter-core communicationover a coherence bus 464. For example, each cache may have cachecoherency logic/circuitry associated therewith to communicate to overthe coherence bus 464 in response to detected reads or writes toparticular cache lines. In one implementation, a cache snooping protocolis implemented over the coherence bus 464 to snoop cache accesses. Cachesnooping/coherency techniques are well understood by those of skill inthe art and will not be described in detail here to avoid obscuring theunderlying principles described herein.

A proxy circuit 425 may be provided that communicatively couples thegraphics acceleration module 446 to the coherence bus 464, allowing thegraphics acceleration module 446 to participate in the cache coherenceprotocol as a peer of the cores. In particular, an interface 435provides connectivity to the proxy circuit 425 over high-speed link 440(e.g., a PCIe bus, NVLink, etc.) and an interface 437 connects thegraphics acceleration module 446 to the high-speed link 440.

In one implementation, an accelerator integration circuit 436 providescache management, memory access, context management, and interruptmanagement services on behalf of a plurality of graphics processingengines 431, 432, N of the graphics acceleration module 446. Thegraphics processing engines 431, 432, N may each comprise a separategraphics processing unit (GPU). Alternatively, the graphics processingengines 431, 432, N may comprise different types of graphics processingengines within a GPU such as graphics execution units, media processingengines (e.g., video encoders/decoders), samplers, and blit engines. Inother words, the graphics acceleration module may be a GPU with aplurality of graphics processing engines 431-432, N or the graphicsprocessing engines 431-432, N may be individual GPUs integrated on acommon package, line card, or chip.

The accelerator integration circuit 436 may include a memory managementunit (MMU) 439 for performing various memory management functions suchas virtual-to-physical memory translations (also referred to aseffective-to-real memory translations) and memory access protocols foraccessing system memory 441. The MMU 439 may also include a translationlookaside buffer (TLB) (not shown) for caching the virtual/effective tophysical/real address translations. In one implementation, a cache 438stores commands and data for efficient access by the graphics processingengines 431-432, N. The data stored in cache 438 and graphics memories433-434, M may be kept coherent with the core caches 462A-462D, 456 andsystem memory 411. As mentioned, this may be accomplished via proxycircuit 425 which takes part in the cache coherency mechanism on behalfof cache 438 and memories 433-434, M (e.g., sending updates to the cache438 related to modifications/accesses of cache lines on processor caches462A-462D, 456 and receiving updates from the cache 438).

A set of registers 445 store context data for threads executed by thegraphics processing engines 431-432, N and a context management circuit448 manages the thread contexts. For example, the context managementcircuit 448 may perform save and restore operations to save and restorecontexts of the various threads during contexts switches (e.g., where afirst thread is saved and a second thread is stored so that the secondthread can be execute by a graphics processing engine). For example, ona context switch, the context management circuit 448 may store currentregister values to a designated region in memory (e.g., identified by acontext pointer). It may then restore the register values when returningto the context. An interrupt management circuit 447, for example, mayreceive and processes interrupts received from system devices.

In one implementation, virtual/effective addresses from a graphicsprocessing engine 431 are translated to real/physical addresses insystem memory 411 by the MMU 439. Optionally, the acceleratorintegration circuit 436 supports multiple (e.g., 4, 8, 16) graphicsaccelerator modules 446 and/or other accelerator devices. The graphicsaccelerator module 446 may be dedicated to a single application executedon the processor 407 or may be shared between multiple applications.Optionally, a virtualized graphics execution environment is provided inwhich the resources of the graphics processing engines 431-432, N areshared with multiple applications or virtual machines (VMs). Theresources may be subdivided into “slices” which are allocated todifferent VMs and/or applications based on the processing requirementsand priorities associated with the VMs and/or applications.

Thus, the accelerator integration circuit 346 acts as a bridge to thesystem for the graphics acceleration module 446 and provides addresstranslation and system memory cache services. In one embodiment, tofacilitate the bridging functionality, the accelerator integrationcircuit 436 may also include shared I/O 497 (e.g., PCIe, USB) andhardware to enable system control of voltage, clocking, performance,thermals, and security. The shared I/O 497 may utilize separate physicalconnections or may traverse the high-speed link 440. In addition, theaccelerator integration circuit 436 may provide virtualizationfacilities for the host processor to manage virtualization of thegraphics processing engines, interrupts, and memory management.

Because hardware resources of the graphics processing engines 431-432, Nare mapped explicitly to the real address space seen by the hostprocessor 407, any host processor can address these resources directlyusing an effective address value. One optional function of theaccelerator integration circuit 436 is the physical separation of thegraphics processing engines 431-432, N so that they appear to the systemas independent units.

One or more graphics memories 433-434, M may be coupled to each of thegraphics processing engines 431-432, N, respectively. The graphicsmemories 433-434, M store instructions and data being processed by eachof the graphics processing engines 431-432, N. The graphics memories433-434, M may be volatile memories such as DRAMs (including stackedDRAMs), GDDR memory (e.g., GDDR5, GDDR6), or HBM, and/or may benon-volatile memories such as 3D XPoint/Optane or Nano-Ram.

To reduce data traffic over the high-speed link 440, biasing techniquesmay be used to ensure that the data stored in graphics memories 433-434,M is data which will be used most frequently by the graphics processingengines 431-432, N and preferably not used by the cores 460A-460D (atleast not frequently). Similarly, the biasing mechanism attempts to keepdata needed by the cores (and preferably not the graphics processingengines 431-432, N) within the caches 462A-462D, 456 of the cores andsystem memory 411.

According to a variant shown in FIG. 4C the accelerator integrationcircuit 436 is integrated within the processor 407. The graphicsprocessing engines 431-432, N communicate directly over the high-speedlink 440 to the accelerator integration circuit 436 via interface 437and interface 435 (which, again, may be utilize any form of bus orinterface protocol). The accelerator integration circuit 436 may performthe same operations as those described with respect to FIG. 4B, butpotentially at a higher throughput given its close proximity to thecoherency bus 464 and caches 462A-462D, 456.

The embodiments described may support different programming modelsincluding a dedicated-process programming model (no graphicsacceleration module virtualization) and shared programming models (withvirtualization). The latter may include programming models which arecontrolled by the accelerator integration circuit 436 and programmingmodels which are controlled by the graphics acceleration module 446.

In the embodiments of the dedicated process model, graphics processingengines 431-432, N may be dedicated to a single application or processunder a single operating system. The single application can funnel otherapplication requests to the graphics engines 431-432, N, providingvirtualization within a VM/partition.

In the dedicated-process programming models, the graphics processingengines 431-432, N, may be shared by multiple VM/application partitions.The shared models require a system hypervisor to virtualize the graphicsprocessing engines 431-432, N to allow access by each operating system.For single-partition systems without a hypervisor, the graphicsprocessing engines 431-432, N are owned by the operating system. In bothcases, the operating system can virtualize the graphics processingengines 431-432, N to provide access to each process or application.

For the shared programming model, the graphics acceleration module 446or an individual graphics processing engine 431-432, N selects a processelement using a process handle. The process elements may be stored insystem memory 411 and be addressable using the effective address to realaddress translation techniques described herein. The process handle maybe an implementation-specific value provided to the host process whenregistering its context with the graphics processing engine 431-432, N(that is, calling system software to add the process element to theprocess element linked list). The lower 16-bits of the process handlemay be the offset of the process element within the process elementlinked list.

FIG. 4D illustrates an exemplary accelerator integration slice 490. Asused herein, a “slice” comprises a specified portion of the processingresources of the accelerator integration circuit 436. Applicationeffective address space 482 within system memory 411 stores processelements 483. The process elements 483 may be stored in response to GPUinvocations 481 from applications 480 executed on the processor 407. Aprocess element 483 contains the process state for the correspondingapplication 480. A work descriptor (WD) 484 contained in the processelement 483 can be a single job requested by an application or maycontain a pointer to a queue of jobs. In the latter case, the WD 484 isa pointer to the job request queue in the application's address space482.

The graphics acceleration module 446 and/or the individual graphicsprocessing engines 431-432, N can be shared by all or a subset of theprocesses in the system. For example, the technologies described hereinmay include an infrastructure for setting up the process state andsending a WD 484 to a graphics acceleration module 446 to start a job ina virtualized environment.

In one implementation, the dedicated-process programming model isimplementation-specific. In this model, a single process owns thegraphics acceleration module 446 or an individual graphics processingengine 431. Because the graphics acceleration module 446 is owned by asingle process, the hypervisor initializes the accelerator integrationcircuit 436 for the owning partition and the operating systeminitializes the accelerator integration circuit 436 for the owningprocess at the time when the graphics acceleration module 446 isassigned.

In operation, a WD fetch unit 491 in the accelerator integration slice490 fetches the next WD 484 which includes an indication of the work tobe done by one of the graphics processing engines of the graphicsacceleration module 446. Data from the WD 484 may be stored in registers445 and used by the MMU 439, interrupt management circuit 447 and/orcontext management circuit 448 as illustrated. For example, the MMU 439may include segment/page walk circuitry for accessing segment/pagetables 486 within the OS virtual address space 485. The interruptmanagement circuit 447 may process interrupt events 492 received fromthe graphics acceleration module 446. When performing graphicsoperations, an effective address 493 generated by a graphics processingengine 431-432, N is translated to a real address by the MMU 439.

The same set of registers 445 may be duplicated for each graphicsprocessing engine 431-432, N and/or graphics acceleration module 446 andmay be initialized by the hypervisor or operating system. Each of theseduplicated registers may be included in an accelerator integration slice490. Exemplary registers that may be initialized by the hypervisor areshown in Table 1.

TABLE 1 Hypervisor Initialized Registers 1 Slice Control Register 2 RealAddress (RA) Scheduled Processes Area Pointer 3 Authority Mask OverrideRegister 4 Interrupt Vector Table Entry Offset 5 Interrupt Vector TableEntry Limit 6 State Register 7 Logical Partition ID 8 Real address (RA)Hypervisor Accelerator Utilization Record Pointer 9 Storage DescriptionRegister

Exemplary registers that may be initialized by the operating system areshown in Table 2.

TABLE 2 Operating System Initialized Registers 1 Process and ThreadIdentification 2 Effective Address (EA) Context Save/Restore Pointer 3Virtual Address (VA) Accelerator Utilization Record Pointer 4 VirtualAddress (VA) Storage Segment Table Pointer 5 Authority Mask 6 Workdescriptor

Each WD 484 may be specific to a particular graphics acceleration module446 and/or graphics processing engine 431-432, N. It contains all theinformation a graphics processing engine 431-432, N requires to do itswork or it can be a pointer to a memory location where the applicationhas set up a command queue of work to be completed.

FIG. 4E illustrates additional optional details of a shared model. Itincludes a hypervisor real address space 498 in which a process elementlist 499 is stored. The hypervisor real address space 498 is accessiblevia a hypervisor 496 which virtualizes the graphics acceleration moduleengines for the operating system 495.

The shared programming models allow for all or a subset of processesfrom all or a subset of partitions in the system to use a graphicsacceleration module 446. There are two programming models where thegraphics acceleration module 446 is shared by multiple processes andpartitions: time-sliced shared and graphics directed shared.

In this model, the system hypervisor 496 owns the graphics accelerationmodule 446 and makes its function available to all operating systems495. For a graphics acceleration module 446 to support virtualization bythe system hypervisor 496, the graphics acceleration module 446 mayadhere to the following requirements: 1) An application's job requestmust be autonomous (that is, the state does not need to be maintainedbetween jobs), or the graphics acceleration module 446 must provide acontext save and restore mechanism. 2) An application's job request isguaranteed by the graphics acceleration module 446 to complete in aspecified amount of time, including any translation faults, or thegraphics acceleration module 446 provides the ability to preempt theprocessing of the job. 3) The graphics acceleration module 446 must beguaranteed fairness between processes when operating in the directedshared programming model.

For the shared model, the application 480 may be required to make anoperating system 495 system call with a graphics acceleration module 446type, a work descriptor (WD), an authority mask register (AMR) value,and a context save/restore area pointer (CSRP). The graphicsacceleration module 446 type describes the targeted accelerationfunction for the system call. The graphics acceleration module 446 typemay be a system-specific value. The WD is formatted specifically for thegraphics acceleration module 446 and can be in the form of a graphicsacceleration module 446 command, an effective address pointer to auser-defined structure, an effective address pointer to a queue ofcommands, or any other data structure to describe the work to be done bythe graphics acceleration module 446. In one embodiment, the AMR valueis the AMR state to use for the current process. The value passed to theoperating system is similar to an application setting the AMR. If theaccelerator integration circuit 436 and graphics acceleration module 446implementations do not support a User Authority Mask Override Register(UAMOR), the operating system may apply the current UAMOR value to theAMR value before passing the AMR in the hypervisor call. The hypervisor496 may optionally apply the current Authority Mask Override Register(AMOR) value before placing the AMR into the process element 483. TheCSRP may be one of the registers 445 containing the effective address ofan area in the application's address space 482 for the graphicsacceleration module 446 to save and restore the context state. Thispointer is optional if no state is required to be saved between jobs orwhen a job is preempted. The context save/restore area may be pinnedsystem memory.

Upon receiving the system call, the operating system 495 may verify thatthe application 480 has registered and been given the authority to usethe graphics acceleration module 446. The operating system 495 thencalls the hypervisor 496 with the information shown in Table 3.

TABLE 3 OS to Hypervisor Call Parameters 1 A work descriptor (WD) 2 AnAuthority Mask Register (AMR) value (potentially masked). 3 An effectiveaddress (EA) Context Save/Restore Area Pointer (CSRP) 4 A process ID(PID) and optional thread ID (TID) 5 A virtual address (VA) acceleratorutilization record pointer (AURP) 6 The virtual address of the storagesegment table pointer (SSTP) 7 A logical interrupt service number (LISN)

Upon receiving the hypervisor call, the hypervisor 496 verifies that theoperating system 495 has registered and been given the authority to usethe graphics acceleration module 446. The hypervisor 496 then puts theprocess element 483 into the process element linked list for thecorresponding graphics acceleration module 446 type. The process elementmay include the information shown in Table 4.

TABLE 4 Process Element Information 1 A work descriptor (WD) 2 AnAuthority Mask Register (AMR) value (potentially masked). 3 An effectiveaddress (EA) Context Save/Restore Area Pointer (CSRP) 4 A process ID(PID) and optional thread ID (TID) 5 A virtual address (VA) acceleratorutilization record pointer (AURP) 6 The virtual address of the storagesegment table pointer (SSTP) 7 A logical interrupt service number (LISN)8 Interrupt vector table, derived from the hypervisor call parameters. 9A state register (SR) value 10 A logical partition ID (LPID) 11 A realaddress (RA) hypervisor accelerator utilization record pointer 12 TheStorage Descriptor Register (SDR)

The hypervisor may initialize a plurality of accelerator integrationslice 490 registers 445.

As illustrated in FIG. 4F, in one optional implementation a unifiedmemory addressable via a common virtual memory address space used toaccess the physical processor memories 401-402 and GPU memories 420-423is employed. In this implementation, operations executed on the GPUs410-413 utilize the same virtual/effective memory address space toaccess the processors memories 401-402 and vice versa, therebysimplifying programmability. A first portion of the virtual/effectiveaddress space may be allocated to the processor memory 401, a secondportion to the second processor memory 402, a third portion to the GPUmemory 420, and so on. The entire virtual/effective memory space(sometimes referred to as the effective address space) may thereby bedistributed across each of the processor memories 401-402 and GPUmemories 420-423, allowing any processor or GPU to access any physicalmemory with a virtual address mapped to that memory.

Bias/coherence management circuitry 494A-494E within one or more of theMMUs 439A-439E may be provided that ensures cache coherence between thecaches of the host processors (e.g., 405) and the GPUs 410-413 andimplements biasing techniques indicating the physical memories in whichcertain types of data should be stored. While multiple instances ofbias/coherence management circuitry 494A-494E are illustrated in FIG.4F, the bias/coherence circuitry may be implemented within the MMU ofone or more host processors 405 and/or within the acceleratorintegration circuit 436.

The GPU-attached memory 420-423 may be mapped as part of system memory,and accessed using shared virtual memory (SVM) technology, but withoutsuffering the typical performance drawbacks associated with full systemcache coherence. The ability to GPU-attached memory 420-423 to beaccessed as system memory without onerous cache coherence overheadprovides a beneficial operating environment for GPU offload. Thisarrangement allows the host processor 405 software to setup operands andaccess computation results, without the overhead of tradition I/O DMAdata copies. Such traditional copies involve driver calls, interruptsand memory mapped I/O (MMIO) accesses that are all inefficient relativeto simple memory accesses. At the same time, the ability to access GPUattached memory 420-423 without cache coherence overheads can becritical to the execution time of an offloaded computation. In caseswith substantial streaming write memory traffic, for example, cachecoherence overhead can significantly reduce the effective writebandwidth seen by a GPU 410-413. The efficiency of operand setup, theefficiency of results access, and the efficiency of GPU computation allplay a role in determining the effectiveness of GPU offload.

A selection of between GPU bias and host processor bias may be driven bya bias tracker data structure. A bias table may be used, for example,which may be a page-granular structure (i.e., controlled at thegranularity of a memory page) that includes 1 or 2 bits per GPU-attachedmemory page. The bias table may be implemented in a stolen memory rangeof one or more GPU-attached memories 420-423, with or without a biascache in the GPU 410-413 (e.g., to cache frequently/recently usedentries of the bias table). Alternatively, the entire bias table may bemaintained within the GPU.

In one implementation, the bias table entry associated with each accessto the GPU-attached memory 420-423 is accessed prior the actual accessto the GPU memory, causing the following operations. First, localrequests from the GPU 410-413 that find their page in GPU bias areforwarded directly to a corresponding GPU memory 420-423. Local requestsfrom the GPU that find their page in host bias are forwarded to theprocessor 405 (e.g., over a high-speed link as discussed above).Optionally, requests from the processor 405 that find the requested pagein host processor bias complete the request like a normal memory read.Alternatively, requests directed to a GPU-biased page may be forwardedto the GPU 410-413. The GPU may then transition the page to a hostprocessor bias if it is not currently using the page.

The bias state of a page can be changed either by a software-basedmechanism, a hardware-assisted software-based mechanism, or, for alimited set of cases, a purely hardware-based mechanism.

One mechanism for changing the bias state employs an API call (e.g.OpenCL), which, in turn, calls the GPU's device driver which, in turn,sends a message (or enqueues a command descriptor) to the GPU directingit to change the bias state and, for some transitions, perform a cacheflushing operation in the host. The cache flushing operation is requiredfor a transition from host processor 405 bias to GPU bias, but is notrequired for the opposite transition.

Cache coherency may be maintained by temporarily rendering GPU-biasedpages uncacheable by the host processor 405. To access these pages, theprocessor 405 may request access from the GPU 410 which may or may notgrant access right away, depending on the implementation. Thus, toreduce communication between the host processor 405 and GPU 410 it isbeneficial to ensure that GPU-biased pages are those which are requiredby the GPU but not the host processor 405 and vice versa.

Graphics Processing Pipeline

FIG. 5 illustrates a graphics processing pipeline 500. A graphicsmultiprocessor, such as graphics multiprocessor 234 as in FIG. 2D,graphics multiprocessor 325 of FIG. 3A, graphics multiprocessor 350 ofFIG. 3B can implement the illustrated graphics processing pipeline 500.The graphics multiprocessor can be included within the parallelprocessing subsystems as described herein, such as the parallelprocessor 200 of FIG. 2A, which may be related to the parallelprocessor(s) 112 of FIG. 1 and may be used in place of one of those. Thevarious parallel processing systems can implement the graphicsprocessing pipeline 500 via one or more instances of the parallelprocessing unit (e.g., parallel processing unit 202 of FIG. 2A) asdescribed herein. For example, a shader unit (e.g., graphicsmultiprocessor 234 of FIG. 2C) may be configured to perform thefunctions of one or more of a vertex processing unit 504, a tessellationcontrol processing unit 508, a tessellation evaluation processing unit512, a geometry processing unit 516, and a fragment/pixel processingunit 524. The functions of data assembler 502, primitive assemblers 506,514, 518, tessellation unit 510, rasterizer 522, and raster operationsunit 526 may also be performed by other processing engines within aprocessing cluster (e.g., processing cluster 214 of FIG. 2A) and acorresponding partition unit (e.g., partition unit 220A-220N of FIG.2A). The graphics processing pipeline 500 may also be implemented usingdedicated processing units for one or more functions. It is alsopossible that one or more portions of the graphics processing pipeline500 are performed by parallel processing logic within a general-purposeprocessor (e.g., CPU). Optionally, one or more portions of the graphicsprocessing pipeline 500 can access on-chip memory (e.g., parallelprocessor memory 222 as in FIG. 2A) via a memory interface 528, whichmay be an instance of the memory interface 218 of FIG. 2A. The graphicsprocessor pipeline 500 may also be implemented via a multi-core group365A as in FIG. 3C.

The data assembler 502 is a processing unit that may collect vertex datafor surfaces and primitives. The data assembler 502 then outputs thevertex data, including the vertex attributes, to the vertex processingunit 504. The vertex processing unit 504 is a programmable executionunit that executes vertex shader programs, lighting and transformingvertex data as specified by the vertex shader programs. The vertexprocessing unit 504 reads data that is stored in cache, local or systemmemory for use in processing the vertex data and may be programmed totransform the vertex data from an object-based coordinate representationto a world space coordinate space or a normalized device coordinatespace.

A first instance of a primitive assembler 506 receives vertex attributesfrom the vertex processing unit 504. The primitive assembler 506readings stored vertex attributes as needed and constructs graphicsprimitives for processing by tessellation control processing unit 508.The graphics primitives include triangles, line segments, points,patches, and so forth, as supported by various graphics processingapplication programming interfaces (APIs).

The tessellation control processing unit 508 treats the input verticesas control points for a geometric patch. The control points aretransformed from an input representation from the patch (e.g., thepatch's bases) to a representation that is suitable for use in surfaceevaluation by the tessellation evaluation processing unit 512. Thetessellation control processing unit 508 can also compute tessellationfactors for edges of geometric patches. A tessellation factor applies toa single edge and quantifies a view-dependent level of detail associatedwith the edge. A tessellation unit 510 is configured to receive thetessellation factors for edges of a patch and to tessellate the patchinto multiple geometric primitives such as line, triangle, orquadrilateral primitives, which are transmitted to a tessellationevaluation processing unit 512. The tessellation evaluation processingunit 512 operates on parameterized coordinates of the subdivided patchto generate a surface representation and vertex attributes for eachvertex associated with the geometric primitives.

A second instance of a primitive assembler 514 receives vertexattributes from the tessellation evaluation processing unit 512, readingstored vertex attributes as needed, and constructs graphics primitivesfor processing by the geometry processing unit 516. The geometryprocessing unit 516 is a programmable execution unit that executesgeometry shader programs to transform graphics primitives received fromprimitive assembler 514 as specified by the geometry shader programs.The geometry processing unit 516 may be programmed to subdivide thegraphics primitives into one or more new graphics primitives andcalculate parameters used to rasterize the new graphics primitives.

The geometry processing unit 516 may be able to add or delete elementsin the geometry stream. The geometry processing unit 516 outputs theparameters and vertices specifying new graphics primitives to primitiveassembler 518. The primitive assembler 518 receives the parameters andvertices from the geometry processing unit 516 and constructs graphicsprimitives for processing by a viewport scale, cull, and clip unit 520.The geometry processing unit 516 reads data that is stored in parallelprocessor memory or system memory for use in processing the geometrydata. The viewport scale, cull, and clip unit 520 performs clipping,culling, and viewport scaling and outputs processed graphics primitivesto a rasterizer 522.

The rasterizer 522 can perform depth culling and other depth-basedoptimizations. The rasterizer 522 also performs scan conversion on thenew graphics primitives to generate fragments and output those fragmentsand associated coverage data to the fragment/pixel processing unit 524.The fragment/pixel processing unit 524 is a programmable execution unitthat is configured to execute fragment shader programs or pixel shaderprograms. The fragment/pixel processing unit 524 transforming fragmentsor pixels received from rasterizer 522, as specified by the fragment orpixel shader programs. For example, the fragment/pixel processing unit524 may be programmed to perform operations included but not limited totexture mapping, shading, blending, texture correction and perspectivecorrection to produce shaded fragments or pixels that are output to araster operations unit 526. The fragment/pixel processing unit 524 canread data that is stored in either the parallel processor memory or thesystem memory for use when processing the fragment data. Fragment orpixel shader programs may be configured to shade at sample, pixel, tile,or other granularities depending on the sampling rate configured for theprocessing units.

The raster operations unit 526 is a processing unit that performs rasteroperations including, but not limited to stencil, z-test, blending, andthe like, and outputs pixel data as processed graphics data to be storedin graphics memory (e.g., parallel processor memory 222 as in FIG. 2A,and/or system memory 104 as in FIG. 1), to be displayed on the one ormore display device(s) 110 or for further processing by one of the oneor more processor(s) 102 or parallel processor(s) 112. The rasteroperations unit 526 may be configured to compress z or color data thatis written to memory and decompress z or color data that is read frommemory.

Machine Learning Overview

The architecture described above can be applied to perform training andinference operations using machine learning models. Machine learning hasbeen successful at solving many kinds of tasks. The computations thatarise when training and using machine learning algorithms (e.g., neuralnetworks) lend themselves naturally to efficient parallelimplementations. Accordingly, parallel processors such asgeneral-purpose graphic processing units (GPGPUs) have played asignificant role in the practical implementation of deep neuralnetworks. Parallel graphics processors with single instruction, multiplethread (SIMT) architectures are designed to maximize the amount ofparallel processing in the graphics pipeline. In an SIMT architecture,groups of parallel threads attempt to execute program instructionssynchronously together as often as possible to increase processingefficiency. The efficiency provided by parallel machine learningalgorithm implementations allows the use of high capacity networks andenables those networks to be trained on larger datasets.

A machine learning algorithm is an algorithm that can learn based on aset of data. For example, machine learning algorithms can be designed tomodel high-level abstractions within a data set. For example, imagerecognition algorithms can be used to determine which of severalcategories to which a given input belong; regression algorithms canoutput a numerical value given an input; and pattern recognitionalgorithms can be used to generate translated text or perform text tospeech and/or speech recognition.

An exemplary type of machine learning algorithm is a neural network.There are many types of neural networks; a simple type of neural networkis a feedforward network. A feedforward network may be implemented as anacyclic graph in which the nodes are arranged in layers. Typically, afeedforward network topology includes an input layer and an output layerthat are separated by at least one hidden layer. The hidden layertransforms input received by the input layer into a representation thatis useful for generating output in the output layer. The network nodesare fully connected via edges to the nodes in adjacent layers, but thereare no edges between nodes within each layer. Data received at the nodesof an input layer of a feedforward network are propagated (i.e., “fedforward”) to the nodes of the output layer via an activation functionthat calculates the states of the nodes of each successive layer in thenetwork based on coefficients (“weights”) respectively associated witheach of the edges connecting the layers. Depending on the specific modelbeing represented by the algorithm being executed, the output from theneural network algorithm can take various forms.

Before a machine learning algorithm can be used to model a particularproblem, the algorithm is trained using a training data set. Training aneural network involves selecting a network topology, using a set oftraining data representing a problem being modeled by the network, andadjusting the weights until the network model performs with a minimalerror for all instances of the training data set. For example, during asupervised learning training process for a neural network, the outputproduced by the network in response to the input representing aninstance in a training data set is compared to the “correct” labeledoutput for that instance, an error signal representing the differencebetween the output and the labeled output is calculated, and the weightsassociated with the connections are adjusted to minimize that error asthe error signal is backward propagated through the layers of thenetwork. The network is considered “trained” when the errors for each ofthe outputs generated from the instances of the training data set areminimized.

The accuracy of a machine learning algorithm can be affectedsignificantly by the quality of the data set used to train thealgorithm. The training process can be computationally intensive and mayrequire a significant amount of time on a conventional general-purposeprocessor. Accordingly, parallel processing hardware is used to trainmany types of machine learning algorithms. This is particularly usefulfor optimizing the training of neural networks, as the computationsperformed in adjusting the coefficients in neural networks lendthemselves naturally to parallel implementations. Specifically, manymachine learning algorithms and software applications have been adaptedto make use of the parallel processing hardware within general-purposegraphics processing devices.

FIG. 6 is a generalized diagram of a machine learning software stack600. A machine learning application 602 can be configured to train aneural network using a training dataset or to use a trained deep neuralnetwork to implement machine intelligence. The machine learningapplication 602 can include training and inference functionality for aneural network and/or specialized software that can be used to train aneural network before deployment. The machine learning application 602can implement any type of machine intelligence including but not limitedto image recognition, mapping and localization, autonomous navigation,speech synthesis, medical imaging, or language translation.

Hardware acceleration for the machine learning application 602 can beenabled via a machine learning framework 604. The machine learningframework 604 can provide a library of machine learning primitives.Machine learning primitives are basic operations that are commonlyperformed by machine learning algorithms Without the machine learningframework 604, developers of machine learning algorithms would berequired to create and optimize the main computational logic associatedwith the machine learning algorithm, then re-optimize the computationallogic as new parallel processors are developed. Instead, the machinelearning application can be configured to perform the necessarycomputations using the primitives provided by the machine learningframework 604. Exemplary primitives include tensor convolutions,activation functions, and pooling, which are computational operationsthat are performed while training a convolutional neural network (CNN).The machine learning framework 604 can also provide primitives toimplement basic linear algebra subprograms performed by manymachine-learning algorithms, such as matrix and vector operations.

The machine learning framework 604 can process input data received fromthe machine learning application 602 and generate the appropriate inputto a compute framework 606. The compute framework 606 can abstract theunderlying instructions provided to the GPGPU driver 608 to enable themachine learning framework 604 to take advantage of hardwareacceleration via the GPGPU hardware 610 without requiring the machinelearning framework 604 to have intimate knowledge of the architecture ofthe GPGPU hardware 610. Additionally, the compute framework 606 canenable hardware acceleration for the machine learning framework 604across a variety of types and generations of the GPGPU hardware 610.

GPGPU Machine Learning Acceleration

FIG. 7 illustrates a general-purpose graphics processing unit 700, whichmay be the parallel processor 200 of FIG. 2A or the parallelprocessor(s) 112 of FIG. 1. The general-purpose processing unit (GPGPU)700 may be configured to be particularly efficient in processing thetype of computational workloads associated with training deep neuralnetworks. Additionally, the GPGPU 700 can be linked directly to otherinstances of the GPGPU to create a multi-GPU cluster to improve trainingspeed for particularly deep neural networks.

The GPGPU 700 includes a host interface 702 to enable a connection witha host processor. The host interface 702 may be a PCI Express interface.However, the host interface can also be a vendor specific communicationsinterface or communications fabric. The GPGPU 700 receives commands fromthe host processor and uses a global scheduler 704 to distributeexecution threads associated with those commands to a set of processingclusters 706A-706H. The processing clusters 706A-706H share a cachememory 708. The cache memory 708 can serve as a higher-level cache forcache memories within the processing clusters 706A-706H. The illustratedprocessing clusters 706A-706H may correspond with processing clusters214A-214N as in FIG. 2A.

The GPGPU 700 includes memory 714A-714B coupled with the processingclusters 706A-H via a set of memory controllers 712A-712B. The memory714A-714B can include various types of memory devices including dynamicrandom-access memory (DRAM) or graphics random access memory, such assynchronous graphics random access memory (SGRAM), including graphicsdouble data rate (GDDR) memory. The memory 714A-714B may also include 3Dstacked memory, including but not limited to high bandwidth memory(HBM).

Each of the processing clusters 706A-706H may include a set of graphicsmultiprocessors, such as the graphics multiprocessor 234 of FIG. 2D,graphics multiprocessor 325 of FIG. 3A, graphics multiprocessor 350 ofFIG. 3B, or may include a multi-core group 365A-365N as in FIG. 3C. Thegraphics multiprocessors of the compute cluster include multiple typesof integer and floating-point logic units that can perform computationaloperations at a range of precisions including suited for machinelearning computations. For example, at least a subset of thefloating-point units in each of the processing clusters 706A-706H can beconfigured to perform 16-bit or 32-bit floating point operations, whilea different subset of the floating-point units can be configured toperform 64-bit floating point operations.

Multiple instances of the GPGPU 700 can be configured to operate as acompute cluster. The communication mechanism used by the compute clusterfor synchronization and data exchange varies across embodiments. Forexample, the multiple instances of the GPGPU 700 communicate over thehost interface 702. In one embodiment the GPGPU 700 includes an I/O hub709 that couples the GPGPU 700 with a GPU link 710 that enables a directconnection to other instances of the GPGPU. The GPU link 710 may becoupled to a dedicated GPU-to-GPU bridge that enables communication andsynchronization between multiple instances of the GPGPU 700. Optionally,the GPU link 710 couples with a high-speed interconnect to transmit andreceive data to other GPGPUs or parallel processors. The multipleinstances of the GPGPU 700 may be located in separate data processingsystems and communicate via a network device that is accessible via thehost interface 702. The GPU link 710 may be configured to enable aconnection to a host processor in addition to or as an alternative tothe host interface 702.

While the illustrated configuration of the GPGPU 700 can be configuredto train neural networks, an alternate configuration of the GPGPU 700can be configured for deployment within a high performance or low powerinferencing platform. In an inferencing configuration, the GPGPU 700includes fewer of the processing clusters 706A-706H relative to thetraining configuration. Additionally, memory technology associated withthe memory 714A-714B may differ between inferencing and trainingconfigurations. In one embodiment, the inferencing configuration of theGPGPU 700 can support inferencing specific instructions. For example, aninferencing configuration can provide support for one or more 8-bitinteger dot product instructions, which are commonly used duringinferencing operations for deployed neural networks.

FIG. 8 illustrates a multi-GPU computing system 800. The multi-GPUcomputing system 800 can include a processor 802 coupled to multipleGPGPUs 806A-806D via a host interface switch 804. The host interfaceswitch 804 may be a PCI express switch device that couples the processor802 to a PCI express bus over which the processor 802 can communicatewith the set of GPGPUs 806A-806D. Each of the multiple GPGPUs 806A-806Dcan be an instance of the GPGPU 700 of FIG. 7. The GPGPUs 806A-806D caninterconnect via a set of high-speed point to point GPU to GPU links816. The high-speed GPU to GPU links can connect to each of the GPGPUs806A-806D via a dedicated GPU link, such as the GPU link 710 as in FIG.7. The P2P GPU links 816 enable direct communication between each of theGPGPUs 806A-806D without requiring communication over the host interfacebus to which the processor 802 is connected. With GPU-to-GPU trafficdirected to the P2P GPU links, the host interface bus remains availablefor system memory access or to communicate with other instances of themulti-GPU computing system 800, for example, via one or more networkdevices. While in FIG. 8 the GPGPUs 806A-806D connect to the processor802 via the host interface switch 804, the processor 802 mayalternatively include direct support for the P2P GPU links 816 andconnect directly to the GPGPUs 806A-806D.

Machine Learning Neural Network Implementations

The computing architecture described herein can be configured to performthe types of parallel processing that is particularly suited fortraining and deploying neural networks for machine learning. A neuralnetwork can be generalized as a network of functions having a graphrelationship. As is well-known in the art, there are a variety of typesof neural network implementations used in machine learning. Oneexemplary type of neural network is the feedforward network, aspreviously described.

A second exemplary type of neural network is the Convolutional NeuralNetwork (CNN). A CNN is a specialized feedforward neural network forprocessing data having a known, grid-like topology, such as image data.Accordingly, CNNs are commonly used for compute vision and imagerecognition applications, but they also may be used for other types ofpattern recognition such as speech and language processing. The nodes inthe CNN input layer are organized into a set of “filters” (featuredetectors inspired by the receptive fields found in the retina), and theoutput of each set of filters is propagated to nodes in successivelayers of the network. The computations for a CNN include applying theconvolution mathematical operation to each filter to produce the outputof that filter. Convolution is a specialized kind of mathematicaloperation performed by two functions to produce a third function that isa modified version of one of the two original functions. Inconvolutional network terminology, the first function to the convolutioncan be referred to as the input, while the second function can bereferred to as the convolution kernel. The output may be referred to asthe feature map. For example, the input to a convolution layer can be amultidimensional array of data that defines the various color componentsof an input image. The convolution kernel can be a multidimensionalarray of parameters, where the parameters are adapted by the trainingprocess for the neural network.

Recurrent neural networks (RNNs) are a family of feedforward neuralnetworks that include feedback connections between layers. RNNs enablemodeling of sequential data by sharing parameter data across differentparts of the neural network. The architecture for an RNN includescycles. The cycles represent the influence of a present value of avariable on its own value at a future time, as at least a portion of theoutput data from the RNN is used as feedback for processing subsequentinput in a sequence. This feature makes RNNs particularly useful forlanguage processing due to the variable nature in which language datacan be composed.

The figures described below present exemplary feedforward, CNN, and RNNnetworks, as well as describe a general process for respectivelytraining and deploying each of those types of networks. It will beunderstood that these descriptions are exemplary and non-limiting as toany specific embodiment described herein and the concepts illustratedcan be applied generally to deep neural networks and machine learningtechniques in general.

The exemplary neural networks described above can be used to performdeep learning. Deep learning is machine learning using deep neuralnetworks. The deep neural networks used in deep learning are artificialneural networks composed of multiple hidden layers, as opposed toshallow neural networks that include only a single hidden layer. Deeperneural networks are generally more computationally intensive to train.However, the additional hidden layers of the network enable multisteppattern recognition that results in reduced output error relative toshallow machine learning techniques.

Deep neural networks used in deep learning typically include a front-endnetwork to perform feature recognition coupled to a back-end networkwhich represents a mathematical model that can perform operations (e.g.,object classification, speech recognition, etc.) based on the featurerepresentation provided to the model. Deep learning enables machinelearning to be performed without requiring hand crafted featureengineering to be performed for the model. Instead, deep neural networkscan learn features based on statistical structure or correlation withinthe input data. The learned features can be provided to a mathematicalmodel that can map detected features to an output. The mathematicalmodel used by the network is generally specialized for the specific taskto be performed, and different models will be used to perform differenttask.

Once the neural network is structured, a learning model can be appliedto the network to train the network to perform specific tasks. Thelearning model describes how to adjust the weights within the model toreduce the output error of the network. Backpropagation of errors is acommon method used to train neural networks. An input vector ispresented to the network for processing. The output of the network iscompared to the desired output using a loss function and an error valueis calculated for each of the neurons in the output layer. The errorvalues are then propagated backwards until each neuron has an associatederror value which roughly represents its contribution to the originaloutput. The network can then learn from those errors using an algorithm,such as the stochastic gradient descent algorithm, to update the weightsof the of the neural network.

FIG. 9A-9B illustrate an exemplary convolutional neural network. FIG. 9Aillustrates various layers within a CNN. As shown in FIG. 9A, anexemplary CNN used to model image processing can receive input 902describing the red, green, and blue (RGB) components of an input image.The input 902 can be processed by multiple convolutional layers (e.g.,convolutional layer 904, convolutional layer 906). The output from themultiple convolutional layers may optionally be processed by a set offully connected layers 908. Neurons in a fully connected layer have fullconnections to all activations in the previous layer, as previouslydescribed for a feedforward network. The output from the fully connectedlayers 908 can be used to generate an output result from the network.The activations within the fully connected layers 908 can be computedusing matrix multiplication instead of convolution. Not all CNNimplementations make use of fully connected layers 908. For example, insome implementations the convolutional layer 906 can generate output forthe CNN.

The convolutional layers are sparsely connected, which differs fromtraditional neural network configuration found in the fully connectedlayers 908. Traditional neural network layers are fully connected, suchthat every output unit interacts with every input unit. However, theconvolutional layers are sparsely connected because the output of theconvolution of a field is input (instead of the respective state valueof each of the nodes in the field) to the nodes of the subsequent layer,as illustrated. The kernels associated with the convolutional layersperform convolution operations, the output of which is sent to the nextlayer. The dimensionality reduction performed within the convolutionallayers is one aspect that enables the CNN to scale to process largeimages.

FIG. 9B illustrates exemplary computation stages within a convolutionallayer of a CNN. Input to a convolutional layer 912 of a CNN can beprocessed in three stages of a convolutional layer 914. The three stagescan include a convolution stage 916, a detector stage 918, and a poolingstage 920. The convolution layer 914 can then output data to asuccessive convolutional layer. The final convolutional layer of thenetwork can generate output feature map data or provide input to a fullyconnected layer, for example, to generate a classification value for theinput to the CNN.

In the convolution stage 916 performs several convolutions in parallelto produce a set of linear activations. The convolution stage 916 caninclude an affine transformation, which is any transformation that canbe specified as a linear transformation plus a translation. Affinetransformations include rotations, translations, scaling, andcombinations of these transformations. The convolution stage computesthe output of functions (e.g., neurons) that are connected to specificregions in the input, which can be determined as the local regionassociated with the neuron. The neurons compute a dot product betweenthe weights of the neurons and the region in the local input to whichthe neurons are connected. The output from the convolution stage 916defines a set of linear activations that are processed by successivestages of the convolutional layer 914.

The linear activations can be processed by a detector stage 918. In thedetector stage 918, each linear activation is processed by a non-linearactivation function. The non-linear activation function increases thenonlinear properties of the overall network without affecting thereceptive fields of the convolution layer. Several types of non-linearactivation functions may be used. One particular type is the rectifiedlinear unit (ReLU), which uses an activation function defined asƒ(x)=max (0,x), such that the activation is thresholded at zero.

The pooling stage 920 uses a pooling function that replaces the outputof the convolutional layer 906 with a summary statistic of the nearbyoutputs. The pooling function can be used to introduce translationinvariance into the neural network, such that small translations to theinput do not change the pooled outputs. Invariance to local translationcan be useful in scenarios where the presence of a feature in the inputdata is more important than the precise location of the feature. Varioustypes of pooling functions can be used during the pooling stage 920,including max pooling, average pooling, and l2-norm pooling.Additionally, some CNN implementations do not include a pooling stage.Instead, such implementations substitute and additional convolutionstage having an increased stride relative to previous convolutionstages.

The output from the convolutional layer 914 can then be processed by thenext layer 922. The next layer 922 can be an additional convolutionallayer or one of the fully connected layers 908. For example, the firstconvolutional layer 904 of FIG. 9A can output to the secondconvolutional layer 906, while the second convolutional layer can outputto a first layer of the fully connected layers 908.

FIG. 10 illustrates an exemplary recurrent neural network 1000. In arecurrent neural network (RNN), the previous state of the networkinfluences the output of the current state of the network. RNNs can bebuilt in a variety of ways using a variety of functions. The use of RNNsgenerally revolves around using mathematical models to predict thefuture based on a prior sequence of inputs. For example, an RNN may beused to perform statistical language modeling to predict an upcomingword given a previous sequence of words. The illustrated RNN 1000 can bedescribed has having an input layer 1002 that receives an input vector,hidden layers 1004 to implement a recurrent function, a feedbackmechanism 1005 to enable a ‘memory’ of previous states, and an outputlayer 1006 to output a result. The RNN 1000 operates based ontime-steps. The state of the RNN at a given time step is influencedbased on the previous time step via the feedback mechanism 1005. For agiven time step, the state of the hidden layers 1004 is defined by theprevious state and the input at the current time step. An initial input(x₁) at a first time step can be processed by the hidden layer 1004. Asecond input (x₂) can be processed by the hidden layer 1004 using stateinformation that is determined during the processing of the initialinput (x₁). A given state can be computed as s_(t)=ƒ(Ux_(t)+Ws_(t−1)),where U and W are parameter matrices. The function ƒ is generally anonlinearity, such as the hyperbolic tangent function (Tanh) or avariant of the rectifier function ƒ(x)=max(0,x). However, the specificmathematical function used in the hidden layers 1004 can vary dependingon the specific implementation details of the RNN 1000.

In addition to the basic CNN and RNN networks described, variations onthose networks may be enabled. One example RNN variant is the long shortterm memory (LSTM) RNN. LSTM RNNs are capable of learning long-termdependencies that may be necessary for processing longer sequences oflanguage. A variant on the CNN is a convolutional deep belief network,which has a structure similar to a CNN and is trained in a mannersimilar to a deep belief network. A deep belief network (DBN) is agenerative neural network that is composed of multiple layers ofstochastic (random) variables. DBNs can be trained layer-by-layer usinggreedy unsupervised learning. The learned weights of the DBN can then beused to provide pre-train neural networks by determining an optimalinitial set of weights for the neural network.

FIG. 11 illustrates training and deployment of a deep neural network.Once a given network has been structured for a task the neural networkis trained using a training dataset 1102. Various training frameworks1104 have been developed to enable hardware acceleration of the trainingprocess. For example, the machine learning framework 604 of FIG. 6 maybe configured as a training framework 604. The training framework 604can hook into an untrained neural network 1106 and enable the untrainedneural net to be trained using the parallel processing resourcesdescribed herein to generate a trained neural net 1108.

To start the training process the initial weights may be chosen randomlyor by pre-training using a deep belief network. The training cycle thenbe performed in either a supervised or unsupervised manner.

Supervised learning is a learning method in which training is performedas a mediated operation, such as when the training dataset 1102 includesinput paired with the desired output for the input, or where thetraining dataset includes input having known output and the output ofthe neural network is manually graded. The network processes the inputsand compares the resulting outputs against a set of expected or desiredoutputs. Errors are then propagated back through the system. Thetraining framework 1104 can adjust to adjust the weights that controlthe untrained neural network 1106. The training framework 1104 canprovide tools to monitor how well the untrained neural network 1106 isconverging towards a model suitable to generating correct answers basedon known input data. The training process occurs repeatedly as theweights of the network are adjusted to refine the output generated bythe neural network. The training process can continue until the neuralnetwork reaches a statistically desired accuracy associated with atrained neural net 1108. The trained neural network 1108 can then bedeployed to implement any number of machine learning operations togenerate an inference result 1114 based on input of new data 1112.

Unsupervised learning is a learning method in which the network attemptsto train itself using unlabeled data. Thus, for unsupervised learningthe training dataset 1102 will include input data without any associatedoutput data. The untrained neural network 1106 can learn groupingswithin the unlabeled input and can determine how individual inputs arerelated to the overall dataset. Unsupervised training can be used togenerate a self-organizing map, which is a type of trained neuralnetwork 1108 capable of performing operations useful in reducing thedimensionality of data. Unsupervised training can also be used toperform anomaly detection, which allows the identification of datapoints in an input dataset that deviate from the normal patterns of thedata.

Variations on supervised and unsupervised training may also be employed.Semi-supervised learning is a technique in which in the training dataset1102 includes a mix of labeled and unlabeled data of the samedistribution. Incremental learning is a variant of supervised learningin which input data is continuously used to further train the model.Incremental learning enables the trained neural network 1108 to adapt tothe new data 1112 without forgetting the knowledge instilled within thenetwork during initial training.

Whether supervised or unsupervised, the training process forparticularly deep neural networks may be too computationally intensivefor a single compute node. Instead of using a single compute node, adistributed network of computational nodes can be used to accelerate thetraining process.

FIG. 12 is a block diagram illustrating distributed learning.Distributed learning is a training model that uses multiple distributedcomputing nodes to perform supervised or unsupervised training of aneural network. The distributed computational nodes can each include oneor more host processors and one or more of the general-purposeprocessing nodes, such as the highly parallel general-purpose graphicsprocessing unit 700 as in FIG. 7. As illustrated, distributed learningcan be performed model parallelism 1202, data parallelism 1204, or acombination of model and data parallelism 1204.

In model parallelism 1202, different computational nodes in adistributed system can perform training computations for different partsof a single network. For example, each layer of a neural network can betrained by a different processing node of the distributed system. Thebenefits of model parallelism include the ability to scale toparticularly large models. Splitting the computations associated withdifferent layers of the neural network enables the training of verylarge neural networks in which the weights of all layers would not fitinto the memory of a single computational node. In some instances, modelparallelism can be particularly useful in performing unsupervisedtraining of large neural networks.

In data parallelism 1204, the different nodes of the distributed networkhave a complete instance of the model and each node receives a differentportion of the data. The results from the different nodes are thencombined. While different approaches to data parallelism are possible,data parallel training approaches all require a technique of combiningresults and synchronizing the model parameters between each node.Exemplary approaches to combining data include parameter averaging andupdate based data parallelism. Parameter averaging trains each node on asubset of the training data and sets the global parameters (e.g.,weights, biases) to the average of the parameters from each node.Parameter averaging uses a central parameter server that maintains theparameter data. Update based data parallelism is similar to parameteraveraging except that instead of transferring parameters from the nodesto the parameter server, the updates to the model are transferred.Additionally, update based data parallelism can be performed in adecentralized manner, where the updates are compressed and transferredbetween nodes.

Combined model and data parallelism 1206 can be implemented, forexample, in a distributed system in which each computational nodeincludes multiple GPUs. Each node can have a complete instance of themodel with separate GPUs within each node are used to train differentportions of the model.

Distributed training has increased overhead relative to training on asingle machine. However, the parallel processors and GPGPUs describedherein can each implement various techniques to reduce the overhead ofdistributed training, including techniques to enable high bandwidthGPU-to-GPU data transfer and accelerated remote data synchronization.

Exemplary Machine Learning Applications

Machine learning can be applied to solve a variety of technologicalproblems, including but not limited to computer vision, autonomousdriving and navigation, speech recognition, and language processing.Computer vision has traditionally been one of the most active researchareas for machine learning applications. Applications of computer visionrange from reproducing human visual abilities, such as recognizingfaces, to creating new categories of visual abilities. For example,computer vision applications can be configured to recognize sound wavesfrom the vibrations induced in objects visible in a video. Parallelprocessor accelerated machine learning enables computer visionapplications to be trained using significantly larger training datasetthan previously feasible and enables inferencing systems to be deployedusing low power parallel processors.

Parallel processor accelerated machine learning has autonomous drivingapplications including lane and road sign recognition, obstacleavoidance, navigation, and driving control. Accelerated machine learningtechniques can be used to train driving models based on datasets thatdefine the appropriate responses to specific training input. Theparallel processors described herein can enable rapid training of theincreasingly complex neural networks used for autonomous drivingsolutions and enables the deployment of low power inferencing processorsin a mobile platform suitable for integration into autonomous vehicles.

Parallel processor accelerated deep neural networks have enabled machinelearning approaches to automatic speech recognition (ASR). ASR includesthe creation of a function that computes the most probable linguisticsequence given an input acoustic sequence. Accelerated machine learningusing deep neural networks have enabled the replacement of the hiddenMarkov models (HMMs) and Gaussian mixture models (GMMs) previously usedfor ASR.

Parallel processor accelerated machine learning can also be used toaccelerate natural language processing. Automatic learning procedurescan make use of statistical inference algorithms to produce models thatare robust to erroneous or unfamiliar input. Exemplary natural languageprocessor applications include automatic machine translation betweenhuman languages.

The parallel processing platforms used for machine learning can bedivided into training platforms and deployment platforms. Trainingplatforms are generally highly parallel and include optimizations toaccelerate multi-GPU single node training and multi-node, multi-GPUtraining. Exemplary parallel processors suited for training include thegeneral-purpose graphics processing unit 700 of FIG. 7 and the multi-GPUcomputing system 800 of FIG. 8. On the contrary, deployed machinelearning platforms generally include lower power parallel processorssuitable for use in products such as cameras, autonomous robots, andautonomous vehicles.

FIG. 13 illustrates an exemplary inferencing system on a chip (SOC) 1300suitable for performing inferencing using a trained model. The SOC 1300can integrate processing components including a media processor 1302, avision processor 1304, a GPGPU 1306 and a multi-core processor 1308. TheGPGPU 1306 may be a GPGPU as described herein, such as the GPGPU 700,and the multi-core processor 1308 may be a multi-core processordescribed herein, such as the multi-core processors 405-406. The SOC1300 can additionally include on-chip memory 1305 that can enable ashared on-chip data pool that is accessible by each of the processingcomponents. The processing components can be optimized for low poweroperation to enable deployment to a variety of machine learningplatforms, including autonomous vehicles and autonomous robots. Forexample, one implementation of the SOC 1300 can be used as a portion ofthe main control system for an autonomous vehicle. Where the SOC 1300 isconfigured for use in autonomous vehicles the SOC is designed andconfigured for compliance with the relevant functional safety standardsof the deployment jurisdiction.

During operation, the media processor 1302 and vision processor 1304 canwork in concert to accelerate computer vision operations. The mediaprocessor 1302 can enable low latency decode of multiple high-resolution(e.g., 4K, 8K) video streams. The decoded video streams can be writtento a buffer in the on-chip-memory 1305. The vision processor 1304 canthen parse the decoded video and perform preliminary processingoperations on the frames of the decoded video in preparation ofprocessing the frames using a trained image recognition model. Forexample, the vision processor 1304 can accelerate convolution operationsfor a CNN that is used to perform image recognition on thehigh-resolution video data, while back end model computations areperformed by the GPGPU 1306.

The multi-core processor 1308 can include control logic to assist withsequencing and synchronization of data transfers and shared memoryoperations performed by the media processor 1302 and the visionprocessor 1304. The multi-core processor 1308 can also function as anapplication processor to execute software applications that can make useof the inferencing compute capability of the GPGPU 1306. For example, atleast a portion of the navigation and driving logic can be implementedin software executing on the multi-core processor 1308. Such softwarecan directly issue computational workloads to the GPGPU 1306 or thecomputational workloads can be issued to the multi-core processor 1308,which can offload at least a portion of those operations to the GPGPU1306.

The GPGPU 1306 can include compute clusters such as a low powerconfiguration of the processing clusters 706A-706H withingeneral-purpose graphics processing unit 700. The compute clusterswithin the GPGPU 1306 can support instruction that are specificallyoptimized to perform inferencing computations on a trained neuralnetwork. For example, the GPGPU 1306 can support instructions to performlow precision computations such as κ-bit and 4-bit integer vectoroperations.

Additional System Overview

FIG. 14 is a block diagram of a processing system 1400. The elements ofFIG. 14 having the same or similar names as the elements of any otherfigure herein describe the same elements as in the other figures, canoperate or function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such. System 1400 may be usedin a single processor desktop system, a multiprocessor workstationsystem, or a server system having a large number of processors 1402 orprocessor cores 1407. The system 1400 may be a processing platformincorporated within a system-on-a-chip (SoC) integrated circuit for usein mobile, handheld, or embedded devices such as withinInternet-of-things (IoT) devices with wired or wireless connectivity toa local or wide area network.

The system 1400 may be a processing system having components thatcorrespond with those of FIG. 1. For example, in differentconfigurations, processor(s) 1402 or processor core(s) 1407 maycorrespond with processor(s) 102 of FIG. 1. Graphics processor(s) 1408may correspond with parallel processor(s) 112 of FIG. 1. Externalgraphics processor 1418 may be one of the add-in device(s) 120 of FIG.1.

The system 1400 can include, couple with, or be integrated within: aserver-based gaming platform; a game console, including a game and mediaconsole; a mobile gaming console, a handheld game console, or an onlinegame console. The system 1400 may be part of a mobile phone, smartphone, tablet computing device or mobile Internet-connected device suchas a laptop with low internal storage capacity. Processing system 1400can also include, couple with, or be integrated within: a wearabledevice, such as a smart watch wearable device; smart eyewear or clothingenhanced with augmented reality (AR) or virtual reality (VR) features toprovide visual, audio or tactile outputs to supplement real worldvisual, audio or tactile experiences or otherwise provide text, audio,graphics, video, holographic images or video, or tactile feedback; otheraugmented reality (AR) device; or other virtual reality (VR) device. Theprocessing system 1400 may include or be part of a television or set topbox device. The system 1400 can include, couple with, or be integratedwithin a self-driving vehicle such as a bus, tractor trailer, car, motoror electric power cycle, plane or glider (or any combination thereof).The self-driving vehicle may use system 1400 to process the environmentsensed around the vehicle.

The one or more processors 1402 may include one or more processor cores1407 to process instructions which, when executed, perform operationsfor system or user software. The least one of the one or more processorcores 1407 may be configured to process a specific instruction set 1409.The instruction set 1409 may facilitate Complex Instruction SetComputing (CISC), Reduced Instruction Set Computing (RISC), or computingvia a Very Long Instruction Word (VLIW). One or more processor cores1407 may process a different instruction set 1409, which may includeinstructions to facilitate the emulation of other instruction sets.Processor core 1407 may also include other processing devices, such as aDigital Signal Processor (DSP).

The processor 1402 may include cache memory 1404. Depending on thearchitecture, the processor 1402 can have a single internal cache ormultiple levels of internal cache. In some embodiments, the cache memoryis shared among various components of the processor 1402. In someembodiments, the processor 1402 also uses an external cache (e.g., aLevel-3 (L3) cache or Last Level Cache (LLC)) (not shown), which may beshared among processor cores 1407 using known cache coherencytechniques. A register file 1406 can be additionally included inprocessor 1402 and may include different types of registers for storingdifferent types of data (e.g., integer registers, floating pointregisters, status registers, and an instruction pointer register). Someregisters may be general-purpose registers, while other registers may bespecific to the design of the processor 1402.

The one or more processor(s) 1402 may be coupled with one or moreinterface bus(es) 1410 to transmit communication signals such asaddress, data, or control signals between processor 1402 and othercomponents in the system 1400. The interface bus 1410, in one of theseembodiments, can be a processor bus, such as a version of the DirectMedia Interface (DMI) bus. However, processor busses are not limited tothe DMI bus, and may include one or more Peripheral ComponentInterconnect buses (e.g., PCI, PCI express), memory busses, or othertypes of interface busses. For example, the processor(s) 1402 mayinclude an integrated memory controller 1416 and a platform controllerhub 1430. The memory controller 1416 facilitates communication between amemory device and other components of the system 1400, while theplatform controller hub (PCH) 1430 provides connections to I/O devicesvia a local I/O bus.

The memory device 1420 can be a dynamic random-access memory (DRAM)device, a static random-access memory (SRAM) device, flash memorydevice, phase-change memory device, or some other memory device havingsuitable performance to serve as process memory. The memory device 1420can, for example, operate as system memory for the system 1400, to storedata 1422 and instructions 1421 for use when the one or more processors1402 executes an application or process. Memory controller 1416 alsocouples with an optional external graphics processor 1418, which maycommunicate with the one or more graphics processors 1408 in processors1402 to perform graphics and media operations. In some embodiments,graphics, media, and or compute operations may be assisted by anaccelerator 1412 which is a coprocessor that can be configured toperform a specialized set of graphics, media, or compute operations. Forexample, the accelerator 1412 may be a matrix multiplication acceleratorused to optimize machine learning or compute operations. The accelerator1412 can be a ray-tracing accelerator that can be used to performray-tracing operations in concert with the graphics processor 1408. Inone embodiment, an external accelerator 1419 may be used in place of orin concert with the accelerator 1412.

A display device 1411 may be provided that can connect to theprocessor(s) 1402. The display device 1411 can be one or more of aninternal display device, as in a mobile electronic device or a laptopdevice or an external display device attached via a display interface(e.g., DisplayPort, etc.). The display device 1411 can be a head mounteddisplay (HMD) such as a stereoscopic display device for use in virtualreality (VR) applications or augmented reality (AR) applications.

The platform controller hub 1430 may enable peripherals to connect tomemory device 1420 and processor 1402 via a high-speed I/O bus. The I/Operipherals include, but are not limited to, an audio controller 1446, anetwork controller 1434, a firmware interface 1428, a wirelesstransceiver 1426, touch sensors 1425, a data storage device 1424 (e.g.,non-volatile memory, volatile memory, hard disk drive, flash memory,NAND, 3D NAND, 3D XPoint/Optane, etc.). The data storage device 1424 canconnect via a storage interface (e.g., SATA) or via a peripheral bus,such as a Peripheral Component Interconnect bus (e.g., PCI, PCIexpress). The touch sensors 1425 can include touch screen sensors,pressure sensors, or fingerprint sensors. The wireless transceiver 1426can be a Wi-Fi transceiver, a Bluetooth transceiver, or a mobile networktransceiver such as a 3G, 4G, 5G, or Long-Term Evolution (LTE)transceiver. The firmware interface 1428 enables communication withsystem firmware, and can be, for example, a unified extensible firmwareinterface (UEFI). The network controller 1434 can enable a networkconnection to a wired network. In some embodiments, a high-performancenetwork controller (not shown) couples with the interface bus 1410. Theaudio controller 1446 may be a multi-channel high definition audiocontroller. In some of these embodiments the system 1400 includes anoptional legacy I/O controller 1440 for coupling legacy (e.g., PersonalSystem 2 (PS/2)) devices to the system. The platform controller hub 1430can also connect to one or more Universal Serial Bus (USB) controllers1442 connect input devices, such as keyboard and mouse 1443combinations, a camera 1444, or other USB input devices.

It will be appreciated that the system 1400 shown is exemplary and notlimiting, as other types of data processing systems that are differentlyconfigured may also be used. For example, an instance of the memorycontroller 1416 and platform controller hub 1430 may be integrated intoa discreet external graphics processor, such as the external graphicsprocessor 1418. The platform controller hub 1430 and/or memorycontroller 1416 may be external to the one or more processor(s) 1402.For example, the system 1400 can include an external memory controller1416 and platform controller hub 1430, which may be configured as amemory controller hub and peripheral controller hub within a systemchipset that is in communication with the processor(s) 1402.

For example, circuit boards (“sleds”) can be used on which componentssuch as CPUs, memory, and other components are placed are designed forincreased thermal performance Processing components such as theprocessors may be located on a top side of a sled while near memory,such as DIMMs, are located on a bottom side of the sled. As a result ofthe enhanced airflow provided by this design, the components may operateat higher frequencies and power levels than in typical systems, therebyincreasing performance. Furthermore, the sleds are configured to blindlymate with power and data communication cables in a rack, therebyenhancing their ability to be quickly removed, upgraded, reinstalled,and/or replaced. Similarly, individual components located on the sleds,such as processors, accelerators, memory, and data storage drives, areconfigured to be easily upgraded due to their increased spacing fromeach other. In the illustrative embodiment, the components additionallyinclude hardware attestation features to prove their authenticity.

A data center can utilize a single network architecture (“fabric”) thatsupports multiple other network architectures including Ethernet andOmni-Path. The sleds can be coupled to switches via optical fibers,which provide higher bandwidth and lower latency than typical twistedpair cabling (e.g., Category 5, Category 5e, Category 6, etc.). Due tothe high bandwidth, low latency interconnections and networkarchitecture, the data center may, in use, pool resources, such asmemory, accelerators (e.g., GPUs, graphics accelerators, FPGAs, ASICs,neural network and/or artificial intelligence accelerators, etc.), anddata storage drives that are physically disaggregated, and provide themto compute resources (e.g., processors) on an as needed basis, enablingthe compute resources to access the pooled resources as if they werelocal.

A power supply or source can provide voltage and/or current to system1400 or any component or system described herein. In one example, thepower supply includes an AC to DC (alternating current to directcurrent) adapter to plug into a wall outlet. Such AC power can berenewable energy (e.g., solar power) power source. In one example, thepower source includes a DC power source, such as an external AC to DCconverter. A power source or power supply may also include wirelesscharging hardware to charge via proximity to a charging field. The powersource can include an internal battery, alternating current supply,motion-based power supply, solar power supply, or fuel cell source.

FIG. 15A-15C illustrate computing systems and graphics processors. Theelements of FIG. 15A-15C having the same or similar names as theelements of any other figure herein describe the same elements as in theother figures, can operate or function in a manner similar to that, cancomprise the same components, and can be linked to other entities, asthose described elsewhere herein, but are not limited to such.

FIG. 15A is a block diagram of a processor 1500, which may be a variantof one of the processors 1402 and may be used in place of one of those.Therefore, the disclosure of any features in combination with theprocessor 1500 herein also discloses a corresponding combination withthe processor(s) 1402, but is not limited to such. The processor 1500may have one or more processor cores 1502A-1502N, an integrated memorycontroller 1514, and an integrated graphics processor 1508. Where anintegrated graphics processor 1508 is excluded, the system that includesthe processor will include a graphics processor device within a systemchipset or coupled via a system bus. Processor 1500 can includeadditional cores up to and including additional core 1502N representedby the dashed lined boxes. Each of processor cores 1502A-1502N includesone or more internal cache units 1504A-1504N. In some embodiments eachprocessor core 1502A-1502N also has access to one or more shared cacheunits 1506. The internal cache units 1504A-1504N and shared cache units1506 represent a cache memory hierarchy within the processor 1500. Thecache memory hierarchy may include at least one level of instruction anddata cache within each processor core and one or more levels of sharedmid-level cache, such as a Level 2 (L2), Level 3 (L3), Level 4 (L4), orother levels of cache, where the highest level of cache before externalmemory is classified as the LLC. In some embodiments, cache coherencylogic maintains coherency between the various cache units 1506 and1504A-1504N.

The processor 1500 may also include a set of one or more bus controllerunits 1516 and a system agent core 1510. The one or more bus controllerunits 1516 manage a set of peripheral buses, such as one or more PCI orPCI express busses. System agent core 1510 provides managementfunctionality for the various processor components. The system agentcore 1510 may include one or more integrated memory controllers 1514 tomanage access to various external memory devices (not shown).

For example, one or more of the processor cores 1502A-1502N may includesupport for simultaneous multi-threading. The system agent core 1510includes components for coordinating and operating cores 1502A-1502Nduring multi-threaded processing. System agent core 1510 mayadditionally include a power control unit (PCU), which includes logicand components to regulate the power state of processor cores1502A-1502N and graphics processor 1508.

The processor 1500 may additionally include graphics processor 1508 toexecute graphics processing operations. In some of these embodiments,the graphics processor 1508 couples with the set of shared cache units1506, and the system agent core 1510, including the one or moreintegrated memory controllers 1514. The system agent core 1510 may alsoinclude a display controller 1511 to drive graphics processor output toone or more coupled displays. The display controller 1511 may also be aseparate module coupled with the graphics processor via at least oneinterconnect, or may be integrated within the graphics processor 1508.

A ring-based interconnect unit 1512 may be used to couple the internalcomponents of the processor 1500. However, an alternative interconnectunit may be used, such as a point-to-point interconnect, a switchedinterconnect, or other techniques, including techniques well known inthe art. In some of these embodiments with a ring-based interconnect1512, the graphics processor 1508 couples with the ring-basedinterconnect 1512 via an I/O link 1513.

The exemplary I/O link 1513 represents at least one of multiplevarieties of I/O interconnects, including an on package I/O interconnectwhich facilitates communication between various processor components anda high-performance embedded memory module 1518, such as an eDRAM module.Optionally, each of the processor cores 1502A-1502N and graphicsprocessor 1508 can use embedded memory modules 1518 as a shared LastLevel Cache.

The processor cores 1502A-1502N may, for example, be homogenous coresexecuting the same instruction set architecture. Alternatively, theprocessor cores 1502A-1502N are heterogeneous in terms of instructionset architecture (ISA), where one or more of processor cores 1502A-1502Nexecute a first instruction set, while at least one of the other coresexecutes a subset of the first instruction set or a differentinstruction set. The processor cores 1502A-1502N may be heterogeneous interms of microarchitecture, where one or more cores having a relativelyhigher power consumption couple with one or more power cores having alower power consumption. As another example, the processor cores1502A-1502N are heterogeneous in terms of computational capability.Additionally, processor 1500 can be implemented on one or more chips oras an SoC integrated circuit having the illustrated components, inaddition to other components.

FIG. 15B is a block diagram of hardware logic of a graphics processorcore 1519, according to some embodiments described herein. The graphicsprocessor core 1519, sometimes referred to as a core slice, can be oneor multiple graphics cores within a modular graphics processor. Thegraphics processor core 1519 is exemplary of one graphics core slice,and a graphics processor as described herein may include multiplegraphics core slices based on target power and performance envelopes.Each graphics processor core 1519 can include a fixed function block1530 coupled with multiple sub-cores 1521A-1521F, also referred to assub-slices, that include modular blocks of general-purpose and fixedfunction logic.

The fixed function block 1530 may include a geometry/fixed functionpipeline 1531 that can be shared by all sub-cores in the graphicsprocessor core 1519, for example, in lower performance and/or lowerpower graphics processor implementations. The geometry/fixed functionpipeline 1531 may include a 3D fixed function pipeline (e.g., 3Dpipeline 1612 as in FIG. 16A described below) a video front-end unit, athread spawner and thread dispatcher, and a unified return buffermanager, which manages unified return buffers (e.g., unified returnbuffer 1718 in FIG. 17, as described below).

The fixed function block 1530 may also include a graphics SoC interface1532, a graphics microcontroller 1533, and a media pipeline 1534. Thegraphics SoC interface 1532 provides an interface between the graphicsprocessor core 1519 and other processor cores within a system on a chipintegrated circuit. The graphics microcontroller 1533 is a programmablesub-processor that is configurable to manage various functions of thegraphics processor core 1519, including thread dispatch, scheduling, andpre-emption. The media pipeline 1534 (e.g., media pipeline 1616 of FIG.16A and FIG. 17) includes logic to facilitate the decoding, encoding,pre-processing, and/or post-processing of multimedia data, includingimage and video data. The media pipeline 1534 implement media operationsvia requests to compute or sampling logic within the sub-cores1521-1521F.

The SoC interface 1532 may enable the graphics processor core 1519 tocommunicate with general-purpose application processor cores (e.g.,CPUs) and/or other components within an SoC, including memory hierarchyelements such as a shared last level cache memory, the system RAM,and/or embedded on-chip or on-package DRAM. The SoC interface 1532 canalso enable communication with fixed function devices within the SoC,such as camera imaging pipelines, and enables the use of and/orimplements global memory atomics that may be shared between the graphicsprocessor core 1519 and CPUs within the SoC. The SoC interface 1532 canalso implement power management controls for the graphics processor core1519 and enable an interface between a clock domain of the graphic core1519 and other clock domains within the SoC. Optionally, the SoCinterface 1532 enables receipt of command buffers from a commandstreamer and global thread dispatcher that are configured to providecommands and instructions to each of one or more graphics cores within agraphics processor. The commands and instructions can be dispatched tothe media pipeline 1534, when media operations are to be performed, or ageometry and fixed function pipeline (e.g., geometry and fixed functionpipeline 1531, geometry and fixed function pipeline 1537) when graphicsprocessing operations are to be performed.

The graphics microcontroller 1533 can be configured to perform variousscheduling and management tasks for the graphics processor core 1519. Inone configuration the graphics microcontroller 1533 can, for example,perform graphics and/or compute workload scheduling on the variousgraphics parallel engines within execution unit (EU) arrays 1522A-1522F,1524A-1524F within the sub-cores 1521A-1521F. In this workloadscheduling, host software executing on a CPU core of an SoC includingthe graphics processor core 1519 can submit workloads to one of multiplegraphic processor doorbells, which invokes a scheduling operation on theappropriate graphics engine. Scheduling operations include determiningwhich workload to run next, submitting a workload to a command streamer,pre-empting existing workloads running on an engine, monitoring progressof a workload, and notifying host software when a workload is complete.Optionally, the graphics microcontroller 1533 can also facilitatelow-power or idle states for the graphics processor core 1519, providingthe graphics processor core 1519 with the ability to save and restoreregisters within the graphics processor core 1519 across low-power statetransitions independently from the operating system and/or graphicsdriver software on the system.

The graphics processor core 1519 may have more than or fewer than theillustrated sub-cores 1521A-1521F, up to N modular sub-cores. For eachset of N sub-cores, the graphics processor core 1519 can also includeshared function logic 1535, shared and/or cache memory 1536, ageometry/fixed function pipeline 1537, as well as additional fixedfunction logic 1538 to accelerate various graphics and computeprocessing operations. The shared function logic 1535 can include logicunits associated with the shared function logic 1720 of FIG. 17 (e.g.,sampler, math, and/or inter-thread communication logic) that can beshared by each N sub-cores within the graphics processor core 1519. Theshared and/or cache memory 1536 can be a last-level cache for the set ofN sub-cores 1521A-1521F within the graphics processor core 1519, and canalso serve as shared memory that is accessible by multiple sub-cores.The geometry/fixed function pipeline 1537 can be included instead of thegeometry/fixed function pipeline 1531 within the fixed function block1530 and can include the same or similar logic units.

The graphics processor core 1519 may include additional fixed functionlogic 1538 that can include various fixed function acceleration logicfor use by the graphics processor core 1519. Optionally, the additionalfixed function logic 1538 includes an additional geometry pipeline foruse in position only shading. In position-only shading, two geometrypipelines exist, the full geometry pipeline within the geometry/fixedfunction pipeline 1538, 1531, and a cull pipeline, which is anadditional geometry pipeline which may be included within the additionalfixed function logic 1538. For example, the cull pipeline may be atrimmed down version of the full geometry pipeline. The full pipelineand the cull pipeline can execute different instances of the sameapplication, each instance having a separate context. Position onlyshading can hide long cull runs of discarded triangles, enabling shadingto be completed earlier in some instances. For example, the cullpipeline logic within the additional fixed function logic 1538 canexecute position shaders in parallel with the main application andgenerally generates critical results faster than the full pipeline, asthe cull pipeline fetches and shades only the position attribute of thevertices, without performing rasterization and rendering of the pixelsto the frame buffer. The cull pipeline can use the generated criticalresults to compute visibility information for all the triangles withoutregard to whether those triangles are culled. The full pipeline (whichin this instance may be referred to as a replay pipeline) can consumethe visibility information to skip the culled triangles to shade onlythe visible triangles that are finally passed to the rasterizationphase.

Optionally, the additional fixed function logic 1538 can also includemachine-learning acceleration logic, such as fixed function matrixmultiplication logic, for implementations including optimizations formachine learning training or inferencing.

Within each graphics sub-core 1521A-1521F a set of execution resourcesis included that may be used to perform graphics, media, and computeoperations in response to requests by graphics pipeline, media pipeline,or shader programs. The graphics sub-cores 1521A-1521F include multipleEU arrays 1522A-1522F, 1524A-1524F, thread dispatch and inter-threadcommunication (TD/IC) logic 1523A-1523F, a 3D (e.g., texture) sampler1525A-1525F, a media sampler 1506A-1506F, a shader processor1527A-1527F, and shared local memory (SLM) 1528A-1528F. The EU arrays1522A-1522F, 1524A-1524F each include multiple execution units, whichare general-purpose graphics processing units capable of performingfloating-point and integer/fixed-point logic operations in service of agraphics, media, or compute operation, including graphics, media, orcompute shader programs. The TD/IC logic 1523A-1523F performs localthread dispatch and thread control operations for the execution unitswithin a sub-core and facilitate communication between threads executingon the execution units of the sub-core. The 3D sampler 1525A-1525F canread texture or other 3D graphics related data into memory. The 3Dsampler can read texture data differently based on a configured samplestate and the texture format associated with a given texture. The mediasampler 1506A-1506F can perform similar read operations based on thetype and format associated with media data. For example, each graphicssub-core 1521A-1521F can alternately include a unified 3D and mediasampler. Threads executing on the execution units within each of thesub-cores 1521A-1521F can make use of shared local memory 1528A-1528Fwithin each sub-core, to enable threads executing within a thread groupto execute using a common pool of on-chip memory.

FIG. 15C is a block diagram of general-purpose graphics processing unit(GPGPU) 1570 that can be configured as a graphics processor, e.g. thegraphics processor 1508, and/or compute accelerator, according toembodiments described herein. The GPGPU 1570 can interconnect with hostprocessors (e.g., one or more CPU(s) 1546) and memory 1571, 1572 via oneor more system and/or memory busses. Memory 1571 may be system memorythat can be shared with the one or more CPU(s) 1546, while memory 1572is device memory that is dedicated to the GPGPU 1570. For example,components within the GPGPU 1570 and device memory 1572 may be mappedinto memory addresses that are accessible to the one or more CPU(s)1546. Access to memory 1571 and 1572 may be facilitated via a memorycontroller 1568. The memory controller 1568 may include an internaldirect memory access (DMA) controller 1569 or can include logic toperform operations that would otherwise be performed by a DMAcontroller.

The GPGPU 1570 includes multiple cache memories, including an L2 cache1553, L1 cache 1554, an instruction cache 1555, and shared memory 1556,at least a portion of which may also be partitioned as a cache memory.The GPGPU 1570 also includes multiple compute units 1560A-1560N. Eachcompute unit 1560A-1560N includes a set of vector registers 1561, scalarregisters 1562, vector logic units 1563, and scalar logic units 1564.The compute units 1560A-1560N can also include local shared memory 1565and a program counter 1566. The compute units 1560A-1560N can couplewith a constant cache 1567, which can be used to store constant data,which is data that will not change during the run of kernel or shaderprogram that executes on the GPGPU 1570. The constant cache 1567 may bea scalar data cache and cached data can be fetched directly into thescalar registers 1562.

During operation, the one or more CPU(s) 1546 can write commands intoregisters or memory in the GPGPU 1570 that has been mapped into anaccessible address space. The command processors 1557 can read thecommands from registers or memory and determine how those commands willbe processed within the GPGPU 1570. A thread dispatcher 1558 can then beused to dispatch threads to the compute units 1560A-1560N to performthose commands Each compute unit 1560A-1560N can execute threadsindependently of the other compute units. Additionally, each computeunit 1560A-1560N can be independently configured for conditionalcomputation and can conditionally output the results of computation tomemory. The command processors 1557 can interrupt the one or more CPU(s)1546 when the submitted commands are complete.

FIG. 16A-16C illustrate block diagrams of additional graphics processorand compute accelerator architectures provided by embodiments describedherein, e.g. in accordance with FIG. 15A-15C. The elements of FIG.16A-16C having the same or similar names as the elements of any otherfigure herein describe the same elements as in the other figures, canoperate or function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such.

FIG. 16A is a block diagram of a graphics processor 1600, which may be adiscrete graphics processing unit, or may be a graphics processorintegrated with a plurality of processing cores, or other semiconductordevices such as, but not limited to, memory devices or networkinterfaces. The graphics processor 1600 may be a variant of the graphicsprocessor 1508 and may be used in place of the graphics processor 1508.Therefore, the disclosure of any features in combination with thegraphics processor 1508 herein also discloses a correspondingcombination with the graphics processor 1600, but is not limited tosuch. The graphics processor may communicate via a memory mapped I/Ointerface to registers on the graphics processor and with commandsplaced into the processor memory. Graphics processor 1600 may include amemory interface 1614 to access memory. Memory interface 1614 can be aninterface to local memory, one or more internal caches, one or moreshared external caches, and/or to system memory.

Optionally, graphics processor 1600 also includes a display controller1602 to drive display output data to a display device 1618. Displaycontroller 1602 includes hardware for one or more overlay planes for thedisplay and composition of multiple layers of video or user interfaceelements. The display device 1618 can be an internal or external displaydevice. In one embodiment the display device 1618 is a head mounteddisplay device, such as a virtual reality (VR) display device or anaugmented reality (AR) display device. Graphics processor 1600 mayinclude a video codec engine 1606 to encode, decode, or transcode mediato, from, or between one or more media encoding formats, including, butnot limited to Moving Picture Experts Group (MPEG) formats such asMPEG-2, Advanced Video Coding (AVC) formats such as H.264/MPEG-4 AVC,H.265/HEVC, Alliance for Open Media (AOMedia) VP8, VP9, as well as theSociety of Motion Picture & Television Engineers (SMPTE) 421M/VC-1, andJoint Photographic Experts Group (JPEG) formats such as JPEG, and MotionJPEG (MJPEG) formats.

Graphics processor 1600 may include a block image transfer (BLIT) engine1604 to perform two-dimensional (2D) rasterizer operations including,for example, bit-boundary block transfers. However, alternatively, 2Dgraphics operations may be performed using one or more components ofgraphics processing engine (GPE) 1610. In some embodiments, GPE 1610 isa compute engine for performing graphics operations, includingthree-dimensional (3D) graphics operations and media operations.

GPE 1610 may include a 3D pipeline 1612 for performing 3D operations,such as rendering three-dimensional images and scenes using processingfunctions that act upon 3D primitive shapes (e.g., rectangle, triangle,etc.). The 3D pipeline 1612 includes programmable and fixed functionelements that perform various tasks within the element and/or spawnexecution threads to a 3D/Media sub-system 1615. While 3D pipeline 1612can be used to perform media operations, an embodiment of GPE 1610 alsoincludes a media pipeline 1616 that is specifically used to performmedia operations, such as video post-processing and image enhancement.

Media pipeline 1616 may include fixed function or programmable logicunits to perform one or more specialized media operations, such as videodecode acceleration, video de-interlacing, and video encode accelerationin place of, or on behalf of video codec engine 1606. Media pipeline1616 may additionally include a thread spawning unit to spawn threadsfor execution on 3D/Media sub-system 1615. The spawned threads performcomputations for the media operations on one or more graphics executionunits included in 3D/Media sub-system 1615.

The 3D/Media subsystem 1615 may include logic for executing threadsspawned by 3D pipeline 1612 and media pipeline 1616. The pipelines maysend thread execution requests to 3D/Media subsystem 1615, whichincludes thread dispatch logic for arbitrating and dispatching thevarious requests to available thread execution resources. The executionresources include an array of graphics execution units to process the 3Dand media threads. The 3D/Media subsystem 1615 may include one or moreinternal caches for thread instructions and data. Additionally, the3D/Media subsystem 1615 may also include shared memory, includingregisters and addressable memory, to share data between threads and tostore output data.

FIG. 16B illustrates a graphics processor 1620, being a variant of thegraphics processor 1600 and may be used in place of the graphicsprocessor 1600 and vice versa. Therefore, the disclosure of any featuresin combination with the graphics processor 1600 herein also discloses acorresponding combination with the graphics processor 1620, but is notlimited to such. The graphics processor 1620 has a tiled architecture,according to embodiments described herein. The graphics processor 1620may include a graphics processing engine cluster 1622 having multipleinstances of the graphics processing engine 1610 of FIG. 16A within agraphics engine tile 1610A-1610D. Each graphics engine tile 1610A-1610Dcan be interconnected via a set of tile interconnects 1623A-1623F. Eachgraphics engine tile 1610A-1610D can also be connected to a memorymodule or memory device 1626A-1626D via memory interconnects1625A-1625D. The memory devices 1626A-1626D can use any graphics memorytechnology. For example, the memory devices 1626A-1626D may be graphicsdouble data rate (GDDR) memory. The memory devices 1626A-1626D may behigh-bandwidth memory (HBM) modules that can be on-die with theirrespective graphics engine tile 1610A-1610D. The memory devices1626A-1626D may be stacked memory devices that can be stacked on top oftheir respective graphics engine tile 1610A-1610D. Each graphics enginetile 1610A-1610D and associated memory 1626A-1626D may reside onseparate chiplets, which are bonded to a base die or base substrate, asdescribed in further detail in FIG. 24B-24D.

The graphics processor 1620 may be configured with a non-uniform memoryaccess (NUMA) system in which memory devices 1626A-1626D are coupledwith associated graphics engine tiles 1610A-1610D. A given memory devicemay be accessed by graphics engine tiles other than the tile to which itis directly connected. However, access latency to the memory devices1626A-1626D may be lowest when accessing a local tile. In oneembodiment, a cache coherent NUMA (ccNUMA) system is enabled that usesthe tile interconnects 1623A-1623F to enable communication between cachecontrollers within the graphics engine tiles 1610A-1610D to keep aconsistent memory image when more than one cache stores the same memorylocation.

The graphics processing engine cluster 1622 can connect with an on-chipor on-package fabric interconnect 1624. The fabric interconnect 1624 canenable communication between graphics engine tiles 1610A-1610D andcomponents such as the video codec 1606 and one or more copy engines1604. The copy engines 1604 can be used to move data out of, into, andbetween the memory devices 1626A-1626D and memory that is external tothe graphics processor 1620 (e.g., system memory). The fabricinterconnect 1624 can also be used to interconnect the graphics enginetiles 1610A-1610D. The graphics processor 1620 may optionally include adisplay controller 1602 to enable a connection with an external displaydevice 1618. The graphics processor may also be configured as a graphicsor compute accelerator. In the accelerator configuration, the displaycontroller 1602 and display device 1618 may be omitted.

The graphics processor 1620 can connect to a host system via a hostinterface 1628. The host interface 1628 can enable communication betweenthe graphics processor 1620, system memory, and/or other systemcomponents. The host interface 1628 can be, for example, a PCI expressbus or another type of host system interface.

FIG. 16C illustrates a compute accelerator 1630, according toembodiments described herein. The compute accelerator 1630 can includearchitectural similarities with the graphics processor 1620 of FIG. 16Band is optimized for compute acceleration. A compute engine cluster 1632can include a set of compute engine tiles 1640A-1640D that includeexecution logic that is optimized for parallel or vector-basedgeneral-purpose compute operations. The compute engine tiles 1640A-1640Dmay not include fixed function graphics processing logic, although insome embodiments one or more of the compute engine tiles 1640A-1640D caninclude logic to perform media acceleration. The compute engine tiles1640A-1640D can connect to memory 1626A-1626D via memory interconnects1625A-1625D. The memory 1626A-1626D and memory interconnects 1625A-1625Dmay be similar technology as in graphics processor 1620, or can bedifferent. The graphics compute engine tiles 1640A-1640D can also beinterconnected via a set of tile interconnects 1623A-1623F and may beconnected with and/or interconnected by a fabric interconnect 1624. Inone embodiment the compute accelerator 1630 includes a large L3 cache1636 that can be configured as a device-wide cache. The computeaccelerator 1630 can also connect to a host processor and memory via ahost interface 1628 in a similar manner as the graphics processor 1620of FIG. 16B.

Graphics Processing Engine

FIG. 17 is a block diagram of a graphics processing engine 1710 of agraphics processor in accordance with some embodiments. The graphicsprocessing engine (GPE) 1710 may be a version of the GPE 1610 shown inFIG. 16A, and may also represent a graphics engine tile 1610A-1610D ofFIG. 16B. The elements of FIG. 17 having the same or similar names asthe elements of any other figure herein describe the same elements as inthe other figures, can operate or function in a manner similar to that,can comprise the same components, and can be linked to other entities,as those described elsewhere herein, but are not limited to such. Forexample, the 3D pipeline 1612 and media pipeline 1616 of FIG. 16A arealso illustrated in FIG. 17. The media pipeline 1616 is optional in someembodiments of the GPE 1710 and may not be explicitly included withinthe GPE 1710. For example and in at least one embodiment, a separatemedia and/or image processor is coupled to the GPE 1710.

GPE 1710 may couple with or include a command streamer 1703, whichprovides a command stream to the 3D pipeline 1612 and/or media pipelines1616. Alternatively or additionally, the command streamer 1703 may bedirectly coupled to a unified return buffer 1718. The unified returnbuffer 1718 may be communicatively coupled to a graphics core array1714. Optionally, the command streamer 1703 is coupled with memory,which can be system memory, or one or more of internal cache memory andshared cache memory. The command streamer 1703 may receive commands fromthe memory and sends the commands to 3D pipeline 1612 and/or mediapipeline 1616. The commands are directives fetched from a ring buffer,which stores commands for the 3D pipeline 1612 and media pipeline 1616.The ring buffer can additionally include batch command buffers storingbatches of multiple commands. The commands for the 3D pipeline 1612 canalso include references to data stored in memory, such as but notlimited to vertex and geometry data for the 3D pipeline 1612 and/orimage data and memory objects for the media pipeline 316. The 3Dpipeline 1612 and media pipeline 1616 process the commands and data byperforming operations via logic within the respective pipelines or bydispatching one or more execution threads to the graphics core array1714. The graphics core array 1714 may include one or more blocks ofgraphics cores (e.g., graphics core(s) 1715A, graphics core(s) 1715B),each block including one or more graphics cores. Each graphics coreincludes a set of graphics execution resources that includesgeneral-purpose and graphics specific execution logic to performgraphics and compute operations, as well as fixed function textureprocessing and/or machine learning and artificial intelligenceacceleration logic.

In various embodiments the 3D pipeline 1612 can include fixed functionand programmable logic to process one or more shader programs, such asvertex shaders, geometry shaders, pixel shaders, fragment shaders,compute shaders, or other shader programs, by processing theinstructions and dispatching execution threads to the graphics corearray 1714. The graphics core array 1714 provides a unified block ofexecution resources for use in processing these shader programs.Multi-purpose execution logic (e.g., execution units) within thegraphics core(s) 1715A-1714B of the graphic core array 1714 includessupport for various 3D API shader languages and can execute multiplesimultaneous execution threads associated with multiple shaders.

The graphics core array 1714 may include execution logic to performmedia functions, such as video and/or image processing. The executionunits may include general-purpose logic that is programmable to performparallel general-purpose computational operations, in addition tographics processing operations. The general-purpose logic can performprocessing operations in parallel or in conjunction with general-purposelogic within the processor core(s) 1407 of FIG. 14 or core 1502A-1502Nas in FIG. 15A.

Output data generated by threads executing on the graphics core array1714 can output data to memory in a unified return buffer (URB) 1718.The URB 1718 can store data for multiple threads. The URB 1718 may beused to send data between different threads executing on the graphicscore array 1714. The URB 1718 may additionally be used forsynchronization between threads on the graphics core array 1714 andfixed function logic within the shared function logic 1720.

Optionally, the graphics core array 1714 may be scalable, such that thearray includes a variable number of graphics cores, each having avariable number of execution units based on the target power andperformance level of GPE 1710. The execution resources may bedynamically scalable, such that execution resources may be enabled ordisabled as needed.

The graphics core array 1714 couples with shared function logic 1720that includes multiple resources that are shared between the graphicscores in the graphics core array. The shared functions within the sharedfunction logic 1720 are hardware logic units that provide specializedsupplemental functionality to the graphics core array 1714. In variousembodiments, shared function logic 1720 includes but is not limited tosampler 1721, math 1722, and inter-thread communication (ITC) 1723logic. Additionally, one or more cache(s) 1725 within the sharedfunction logic 1720 may be implemented.

A shared function is implemented at least in a case where the demand fora given specialized function is insufficient for inclusion within thegraphics core array 1714. Instead a single instantiation of thatspecialized function is implemented as a stand-alone entity in theshared function logic 1720 and shared among the execution resourceswithin the graphics core array 1714. The precise set of functions thatare shared between the graphics core array 1714 and included within thegraphics core array 1714 varies across embodiments. Specific sharedfunctions within the shared function logic 1720 that are usedextensively by the graphics core array 1714 may be included withinshared function logic 1716 within the graphics core array 1714.Optionally, the shared function logic 1716 within the graphics corearray 1714 can include some or all logic within the shared functionlogic 1720. All logic elements within the shared function logic 1720 maybe duplicated within the shared function logic 1716 of the graphics corearray 1714. Alternatively, the shared function logic 1720 is excluded infavor of the shared function logic 1716 within the graphics core array1714.

Execution Units

FIG. 18A-18B illustrate thread execution logic 1800 including an arrayof processing elements employed in a graphics processor core accordingto embodiments described herein. The elements of FIG. 18A-18B having thesame or similar names as the elements of any other figure hereindescribe the same elements as in the other figures, can operate orfunction in a manner similar to that, can comprise the same components,and can be linked to other entities, as those described elsewhereherein, but are not limited to such. FIG. 18A-18B illustrates anoverview of thread execution logic 1800, which may be representative ofhardware logic illustrated with each sub-core 1521A-1521F of FIG. 15B.FIG. 18A is representative of an execution unit within a general-purposegraphics processor, while FIG. 18B is representative of an executionunit that may be used within a compute accelerator.

As illustrated in FIG. 18A, thread execution logic 1800 may include ashader processor 1802, a thread dispatcher 1804, instruction cache 1806,a scalable execution unit array including a plurality of execution units1808A-1808N, a sampler 1810, shared local memory 1811, a data cache1812, and a data port 1814. Optionally, the scalable execution unitarray can dynamically scale by enabling or disabling one or moreexecution units (e.g., any of execution units 1808A, 1808B, 1808C,1808D, through 1808N-1 and 1808N) based on the computationalrequirements of a workload. The included components may beinterconnected via an interconnect fabric that links to each of thecomponents. Thread execution logic 1800 may include one or moreconnections to memory, such as system memory or cache memory, throughone or more of instruction cache 1806, data port 1814, sampler 1810, andexecution units 1808A-1808N. Each execution unit (e.g. 1808A) may be astand-alone programmable general-purpose computational unit that iscapable of executing multiple simultaneous hardware threads whileprocessing multiple data elements in parallel for each thread. Invarious embodiments, the array of execution units 1808A-1808N isscalable to include any number individual execution units.

The execution units 1808A-1808N may be primarily used to execute shaderprograms. A shader processor 1802 can process the various shaderprograms and dispatch execution threads associated with the shaderprograms via a thread dispatcher 1804. The thread dispatcher may includelogic to arbitrate thread initiation requests from the graphics andmedia pipelines and instantiate the requested threads on one or moreexecution units 1808A-1808N. For example, a geometry pipeline candispatch vertex, tessellation, or geometry shaders to the threadexecution logic for processing. Optionally, the thread dispatcher 1804can also process runtime thread spawning requests from the executingshader programs.

The execution units 1808A-1808N may support an instruction set thatincludes native support for many standard 3D graphics shaderinstructions, such that shader programs from graphics libraries (e.g.,Direct 3D and OpenGL) are executed with a minimal translation. Theexecution units support vertex and geometry processing (e.g., vertexprograms, geometry programs, vertex shaders), pixel processing (e.g.,pixel shaders, fragment shaders) and general-purpose processing (e.g.,compute and media shaders). Each of the execution units 1808A-1808N iscapable of multi-issue single instruction multiple data (SIMD) executionand multi-threaded operation enables an efficient execution environmentin the face of higher latency memory accesses. Each hardware threadwithin each execution unit has a dedicated high-bandwidth register fileand associated independent thread-state. Execution is multi-issue perclock to pipelines capable of integer, single and double precisionfloating point operations, SIMD branch capability, logical operations,transcendental operations, and other miscellaneous operations. Whilewaiting for data from memory or one of the shared functions, dependencylogic within the execution units 1808A-1808N causes a waiting thread tosleep until the requested data has been returned. While the waitingthread is sleeping, hardware resources may be devoted to processingother threads. For example, during a delay associated with a vertexshader operation, an execution unit can perform operations for a pixelshader, fragment shader, or another type of shader program, including adifferent vertex shader, such as vertex shader 2107 illustrated in FIG.21. Various embodiments can apply to use execution by use of SingleInstruction Multiple Thread (SIMT) as an alternate to use of SIMD or inaddition to use of SIMD. Reference to a SIMD core or operation can applyalso to SIMT or apply to SIMD in combination with SIMT.

Each execution unit in execution units 1808A-1808N operates on arrays ofdata elements. The number of data elements is the “execution size,” orthe number of channels for the instruction. An execution channel is alogical unit of execution for data element access, masking, and flowcontrol within instructions. The number of channels may be independentof the number of physical Arithmetic Logic Units (ALUs), Floating-PointUnits (FPUs), or other logic units (e.g., tensor cores, ray tracingcores, etc.) for a particular graphics processor. Additionally, theexecution units 1808A-1808N may support integer and floating-point datatypes.

The execution unit instruction set includes SIMD instructions. Thevarious data elements can be stored as a packed data type in a registerand the execution unit will process the various elements based on thedata size of the elements. For example, when operating on a 256-bit widevector, the 256 bits of the vector are stored in a register and theexecution unit operates on the vector as four separate 184-bit packeddata elements (Quad-Word (QW) size data elements), eight separate 32-bitpacked data elements (Double Word (DW) size data elements), sixteenseparate 16-bit packed data elements (Word (W) size data elements), orthirty-two separate 8-bit data elements (byte (B) size data elements).However, different vector widths and register sizes are possible.

Optionally, one or more execution units can be combined into a fusedexecution unit 1809A-1809N having thread control logic (1807A-1807N)that is common to the fused EUs. Multiple EUs can be fused into an EUgroup. Each EU in the fused EU group can be configured to execute aseparate SIMD hardware thread. The number of EUs in a fused EU group canvary according to embodiments. Additionally, various SIMD widths can beperformed per-EU, including but not limited to SIMD8, SIMD16, andSIMD32. Each fused graphics execution unit 1809A-1809N includes at leasttwo execution units. For example, fused execution unit 1809A includes afirst EU 1808A, second EU 1808B, and thread control logic 1807A that iscommon to the first EU 1808A and the second EU 1808B. The thread controllogic 1807A controls threads executed on the fused graphics executionunit 1809A, allowing each EU within the fused execution units1809A-1809N to execute using a common instruction pointer register.

One or more internal instruction caches (e.g., 1806) are included in thethread execution logic 1800 to cache thread instructions for theexecution units. One or more data caches (e.g., 1812) may be included inthe thread execution logic 1800 to cache thread data during threadexecution. Threads executing on the execution logic 1800 can also storeexplicitly managed data in the shared local memory 1811. A sampler 1810may be included to provide texture sampling for 3D operations and mediasampling for media operations. Sampler 1810 may include specializedtexture or media sampling functionality to process texture or media dataduring the sampling process before providing the sampled data to anexecution unit.

During execution, the graphics and media pipelines send threadinitiation requests to thread execution logic 1800 via thread spawningand dispatch logic. Once a group of geometric objects has been processedand rasterized into pixel data, pixel processor logic (e.g., pixelshader logic, fragment shader logic, etc.) within the shader processor1802 is invoked to further compute output information and cause resultsto be written to output surfaces (e.g., color buffers, depth buffers,stencil buffers, etc.). A pixel shader or fragment shader may calculatethe values of the various vertex attributes that are to be interpolatedacross the rasterized object. The pixel processor logic within theshader processor 1802 may then execute an application programminginterface (API)-supplied pixel or fragment shader program. To executethe shader program, the shader processor 1802 dispatches threads to anexecution unit (e.g., 1808A) via thread dispatcher 1804. Shaderprocessor 1802 may use texture sampling logic in the sampler 1810 toaccess texture data in texture maps stored in memory. Arithmeticoperations on the texture data and the input geometry data compute pixelcolor data for each geometric fragment, or discards one or more pixelsfrom further processing.

In addition, the data port 1814 may provide a memory access mechanismfor the thread execution logic 1800 to output processed data to memoryfor further processing on a graphics processor output pipeline. The dataport 1814 may include or couple to one or more cache memories (e.g.,data cache 1812) to cache data for memory access via the data port 1814.

Optionally, the execution logic 1800 can also include a ray tracer 1805that can provide ray tracing acceleration functionality. The ray tracer1805 can support a ray tracing instruction set that includesinstructions/functions for ray generation. The ray tracing instructionset can be similar to or different from the ray-tracing instruction setsupported by the ray tracing cores 372 in FIG. 3C.

FIG. 18B illustrates exemplary internal details of an execution unit1808. A graphics execution unit 1808 can include an instruction fetchunit 1837, a general register file array (GRF) 1824, an architecturalregister file array (ARF) 1826, a thread arbiter 1822, a send unit 1830,a branch unit 1832, a set of SIMD floating point units (FPUs) 1834, andoptionally a set of dedicated integer SIMD ALUs 1835. The GRF 1824 andARF 1826 includes the set of general register files and architectureregister files associated with each simultaneous hardware thread thatmay be active in the graphics execution unit 1808. Per threadarchitectural state may be maintained in the ARF 1826, while data usedduring thread execution is stored in the GRF 1824. The execution stateof each thread, including the instruction pointers for each thread, canbe held in thread-specific registers in the ARF 1826.

The graphics execution unit 1808 may have an architecture that is acombination of Simultaneous Multi-Threading (SMT) and fine-grainedInterleaved Multi-Threading (IMT). The architecture may have a modularconfiguration that can be fine-tuned at design time based on a targetnumber of simultaneous threads and number of registers per executionunit, where execution unit resources are divided across logic used toexecute multiple simultaneous threads. The number of logical threadsthat may be executed by the graphics execution unit 1808 is not limitedto the number of hardware threads, and multiple logical threads can beassigned to each hardware thread.

Optionally, the graphics execution unit 1808 can co-issue multipleinstructions, which may each be different instructions. The threadarbiter 1822 of the graphics execution unit thread 1808 can dispatch theinstructions to one of the send unit 1830, branch unit 1832, or SIMDFPU(s) 1834 for execution. Each execution thread can access 128general-purpose registers within the GRF 1824, where each register canstore 32 bytes, accessible as a SIMD 8-element vector of 32-bit dataelements. Each execution unit thread may have access to 4 Kbytes withinthe GRF 1824, although embodiments are not so limited, and greater orfewer register resources may be provided in other embodiments. Thegraphics execution unit 1808 may be partitioned into seven hardwarethreads that can independently perform computational operations,although the number of threads per execution unit can also varyaccording to embodiments, for example, up to 16 hardware threads may besupported. In an exemplary embodiment, in which seven threads may access4 Kbytes, the GRF 1824 can store a total of 28 Kbytes. In anotherexemplary embodiment, where 16 threads may access 4 Kbytes, the GRF 1824can store a total of 64 Kbytes. The number of threads per execution unitare, however, not limited to those examples and may be more or less thanthe given numbers. Flexible addressing modes can permit registers to beaddressed together to build effectively wider registers or to representstrided rectangular block data structures.

Additionally or alternatively, memory operations, sampler operations,and other longer-latency system communications may be dispatched via“send” instructions that are executed by the message passing send unit1830. Branch instructions may be dispatched to a dedicated branch unit1832 to facilitate SIMD divergence and eventual convergence.

The graphics execution unit 1808 may include one or more SIMD floatingpoint units (FPU(s)) 1834 to perform floating-point operations. TheFPU(s) 1834 may also support integer computation. In some instances, theFPU(s) 1834 can SIMD execute up to M number of 32-bit floating-point (orinteger) operations, or SIMD execute up to 2M 16-bit integer or 16-bitfloating-point operations. Optionally, at least one of the FPU(s)provides extended math capability to support high-throughputtranscendental math functions and double precision 184-bitfloating-point. A set of 8-bit integer SIMD ALUs 1835 may also bepresent, and may be specifically optimized to perform operationsassociated with machine learning computations.

Optionally, arrays of multiple instances of the graphics execution unit1808 can be instantiated in a graphics sub-core grouping (e.g., asub-slice). For scalability, product architects can choose the exactnumber of execution units per sub-core grouping. The execution unit 1808may execute instructions across a plurality of execution channels. Inaddition, each thread executed on the graphics execution unit 1808 maybe executed on a different channel.

FIG. 19 illustrates a further exemplary execution unit 1900. Theelements of FIG. 19 having the same or similar names as the elements ofany other figure herein describe the same elements as in the otherfigures, can operate or function in a manner similar to that, cancomprise the same components, and can be linked to other entities, asthose described elsewhere herein, but are not limited to such. Theexecution unit 1900 may be a compute-optimized execution unit for usein, for example, a compute engine tile 1640A-1640D as in FIG. 16C, butis not limited as such. The execution unit 1900 may also be used in agraphics engine tile 1610A-1610D as in FIG. 16B. The execution unit 1900may include a thread control unit 1901, a thread state unit 1902, aninstruction fetch/prefetch unit 1903, and an instruction decode unit1904. The execution unit 1900 may additionally include a register file1906 that stores registers that can be assigned to hardware threadswithin the execution unit. The execution unit 1900 may additionallyinclude a send unit 1907 and a branch unit 1908. The send unit 1907 andbranch unit 1908 may operate similarly as the send unit 1830 and abranch unit 1832 of the graphics execution unit 1808 of FIG. 18B.

The execution unit 1900 can also include a compute unit 1910 thatincludes multiple different types of functional units. The compute unit1910 may also include an ALU unit 1911 that includes an array ofarithmetic logic units. The ALU unit 1911 can be configured to perform64-bit, 32-bit, and 16-bit integer and floating-point operations.Integer and floating-point operations may be performed simultaneously.The compute unit 1910 can also include a systolic array 1912, and a mathunit 1913. The systolic array 1912 includes a W wide and D deep networkof data processing units that can be used to perform vector or otherdata-parallel operations in a systolic manner. The systolic array 1912can be configured to perform matrix operations, such as matrix dotproduct operations. The systolic array 1912 may support 16-bit floatingpoint operations, as well as 8-bit and 4-bit integer operations. Thesystolic array 1912 may be configured to accelerate machine learningoperations. The systolic array 1912 can be configured with support forthe bfloat16, a 16-bit floating point format. A math unit 1913 can beincluded to perform a specific subset of mathematical operations in anefficient and lower-power manner than then ALU unit 1911. The math unit1913 can include math logic found in shared function logic of a graphicsprocessing engine provided by other embodiments described, e.g., themath logic 1722 of the shared function logic 1720 of FIG. 17. The mathunit 1913 can be configured to perform 32-bit and 64-bit floating pointoperations.

The thread control unit 1901 includes logic to control the execution ofthreads within the execution unit. The thread control unit 1901 caninclude thread arbitration logic to start, stop, and preempt executionof threads within the execution unit 1900. The thread state unit 1902can be used to store thread state for threads assigned to execute on theexecution unit 1900. Storing the thread state within the execution unit1900 enables the rapid pre-emption of threads when those threads becomeblocked or idle. The instruction fetch/prefetch unit 1903 can fetchinstructions from an instruction cache of higher-level execution logic(e.g., instruction cache 1806 as in FIG. 18A). The instructionfetch/prefetch unit 1903 can also issue prefetch requests forinstructions to be loaded into the instruction cache based on ananalysis of currently executing threads. The instruction decode unit1904 can be used to decode instructions to be executed by the computeunits. The instruction decode unit 1904 can be used as a secondarydecoder to decode complex instructions into constituentmicro-operations.

The execution unit 1900 additionally includes a register file 1906 thatcan be used by hardware threads executing on the execution unit 1900.Registers in the register file 1906 can be divided across the logic usedto execute multiple simultaneous threads within the compute unit 1910 ofthe execution unit 1900. The number of logical threads that may beexecuted by the graphics execution unit 1900 is not limited to thenumber of hardware threads, and multiple logical threads can be assignedto each hardware thread. The size of the register file 1906 can varyacross embodiments based on the number of supported hardware threads.Register renaming may be used to dynamically allocate registers tohardware threads.

FIG. 20 is a block diagram illustrating a graphics processor instructionformat 2000. The graphics processor execution units support aninstruction set having instructions in multiple formats. The solid linedboxes illustrate the components that are generally included in anexecution unit instruction, while the dashed lines include componentsthat are optional or that are only included in a sub-set of theinstructions. The instruction formats 2000 described and illustrated aremacro-instructions, in that they are instructions supplied to theexecution unit, as opposed to micro-operations resulting frominstruction decode once the instruction is processed.

The graphics processor execution units as described herein may nativelysupport instructions in a 128-bit instruction format 2010. A 64-bitcompacted instruction format 2030 is available for some instructionsbased on the selected instruction, instruction options, and number ofoperands. The native 128-bit instruction format 2010 provides access toall instruction options, while some options and operations arerestricted in the 64-bit format 2030. The native instructions availablein the 64-bit format 2030 vary by embodiment. The instruction iscompacted in part using a set of index values in an index field 2013.The execution unit hardware references a set of compaction tables basedon the index values and uses the compaction table outputs to reconstructa native instruction in the 128-bit instruction format 2010. Other sizesand formats of instruction can be used.

For each format, instruction opcode 2012 defines the operation that theexecution unit is to perform. The execution units execute eachinstruction in parallel across the multiple data elements of eachoperand. For example, in response to an add instruction the executionunit performs a simultaneous add operation across each color channelrepresenting a texture element or picture element. By default, theexecution unit performs each instruction across all data channels of theoperands. Instruction control field 2014 may enable control over certainexecution options, such as channels selection (e.g., predication) anddata channel order (e.g., swizzle). For instructions in the 128-bitinstruction format 2010 an exec-size field 2016 limits the number ofdata channels that will be executed in parallel. An exec-size field 2016may not be available for use in the 64-bit compact instruction format2030.

Some execution unit instructions have up to three operands including twosource operands, src0 2020, src1 2022, and one destination 2018. Theexecution units may support dual destination instructions, where one ofthe destinations is implied. Data manipulation instructions can have athird source operand (e.g., SRC2 2024), where the instruction opcode2012 determines the number of source operands. An instruction's lastsource operand can be an immediate (e.g., hard-coded) value passed withthe instruction.

The 128-bit instruction format 2010 may include an access/address modefield 2026 specifying, for example, whether direct register addressingmode or indirect register addressing mode is used. When direct registeraddressing mode is used, the register address of one or more operands isdirectly provided by bits in the instruction.

The 128-bit instruction format 2010 may also include an access/addressmode field 2026, which specifies an address mode and/or an access modefor the instruction. The access mode may be used to define a data accessalignment for the instruction. Access modes including a 16-byte alignedaccess mode and a 1-byte aligned access mode may be supported, where thebyte alignment of the access mode determines the access alignment of theinstruction operands. For example, when in a first mode, the instructionmay use byte-aligned addressing for source and destination operands andwhen in a second mode, the instruction may use 16-byte-alignedaddressing for all source and destination operands.

The address mode portion of the access/address mode field 2026 maydetermine whether the instruction is to use direct or indirectaddressing. When direct register addressing mode is used bits in theinstruction directly provide the register address of one or moreoperands. When indirect register addressing mode is used, the registeraddress of one or more operands may be computed based on an addressregister value and an address immediate field in the instruction.

Instructions may be grouped based on opcode 2012 bit-fields to simplifyOpcode decode 2040. For an 8-bit opcode, bits 4, 5, and 6 allow theexecution unit to determine the type of opcode. The precise opcodegrouping shown is merely an example. A move and logic opcode group 2042may include data movement and logic instructions (e.g., move (mov),compare (cmp)). Move and logic group 2042 may share the five mostsignificant bits (MSB), where move (mov) instructions are in the form of0000xxxxb and logic instructions are in the form of 0001xxxxb. A flowcontrol instruction group 2044 (e.g., call, jump (jmp)) includesinstructions in the form of 0010xxxxb (e.g., 0x20). A miscellaneousinstruction group 2046 includes a mix of instructions, includingsynchronization instructions (e.g., wait, send) in the form of 0011xxxxb(e.g., 0x30). A parallel math instruction group 2048 includescomponent-wise arithmetic instructions (e.g., add, multiply (mul)) inthe form of 0100xxxxb (e.g., 0x40). The parallel math group 2048performs the arithmetic operations in parallel across data channels. Thevector math group 2050 includes arithmetic instructions (e.g., dp4) inthe form of 0101xxxxb (e.g., 0x50). The vector math group performsarithmetic such as dot product calculations on vector operands. Theillustrated opcode decode 2040, in one embodiment, can be used todetermine which portion of an execution unit will be used to execute adecoded instruction. For example, some instructions may be designated assystolic instructions that will be performed by a systolic array. Otherinstructions, such as ray-tracing instructions (not shown) can be routedto a ray-tracing core or ray-tracing logic within a slice or partitionof execution logic.

Graphics Pipeline

FIG. 21 is a block diagram of graphics processor 2100, according toanother embodiment. The elements of FIG. 21 having the same or similarnames as the elements of any other figure herein describe the sameelements as in the other figures, can operate or function in a mannersimilar to that, can comprise the same components, and can be linked toother entities, as those described elsewhere herein, but are not limitedto such.

The graphics processor 2100 may include different types of graphicsprocessing pipelines, such as a geometry pipeline 2120, a media pipeline2130, a display engine 2140, thread execution logic 2150, and a renderoutput pipeline 2170. Graphics processor 2100 may be a graphicsprocessor within a multi-core processing system that includes one ormore general-purpose processing cores. The graphics processor may becontrolled by register writes to one or more control registers (notshown) or via commands issued to graphics processor 2100 via a ringinterconnect 2102. Ring interconnect 2102 may couple graphics processor2100 to other processing components, such as other graphics processorsor general-purpose processors. Commands from ring interconnect 2102 areinterpreted by a command streamer 2103, which supplies instructions toindividual components of the geometry pipeline 2120 or the mediapipeline 2130.

Command streamer 2103 may direct the operation of a vertex fetcher 2105that reads vertex data from memory and executes vertex-processingcommands provided by command streamer 2103. The vertex fetcher 2105 mayprovide vertex data to a vertex shader 2107, which performs coordinatespace transformation and lighting operations to each vertex. Vertexfetcher 2105 and vertex shader 2107 may execute vertex-processinginstructions by dispatching execution threads to execution units2152A-2152B via a thread dispatcher 2131.

The execution units 2152A-2152B may be an array of vector processorshaving an instruction set for performing graphics and media operations.The execution units 2152A-2152B may have an attached L1 cache 2151 thatis specific for each array or shared between the arrays. The cache canbe configured as a data cache, an instruction cache, or a single cachethat is partitioned to contain data and instructions in differentpartitions.

A geometry pipeline 2120 may include tessellation components to performhardware-accelerated tessellation of 3D objects. A programmable hullshader 2111 may configure the tessellation operations. A programmabledomain shader 2117 may provide back-end evaluation of tessellationoutput. A tessellator 2113 may operate at the direction of hull shader2111 and contain special purpose logic to generate a set of detailedgeometric objects based on a coarse geometric model that is provided asinput to geometry pipeline 2120. In addition, if tessellation is notused, tessellation components (e.g., hull shader 2111, tessellator 2113,and domain shader 2117) can be bypassed.

Complete geometric objects may be processed by a geometry shader 2119via one or more threads dispatched to execution units 2152A-2152B, orcan proceed directly to the clipper 2129. The geometry shader mayoperate on entire geometric objects, rather than vertices or patches ofvertices as in previous stages of the graphics pipeline. If thetessellation is disabled the geometry shader 2119 receives input fromthe vertex shader 2107. The geometry shader 2119 may be programmable bya geometry shader program to perform geometry tessellation if thetessellation units are disabled.

Before rasterization, a clipper 2129 processes vertex data. The clipper2129 may be a fixed function clipper or a programmable clipper havingclipping and geometry shader functions. A rasterizer and depth testcomponent 2173 in the render output pipeline 2170 may dispatch pixelshaders to convert the geometric objects into per pixel representations.The pixel shader logic may be included in thread execution logic 2150.Optionally, an application can bypass the rasterizer and depth testcomponent 2173 and access un-rasterized vertex data via a stream outunit 2123.

The graphics processor 2100 has an interconnect bus, interconnectfabric, or some other interconnect mechanism that allows data andmessage passing amongst the major components of the processor. In someembodiments, execution units 2152A-2152B and associated logic units(e.g., L1 cache 2151, sampler 2154, texture cache 2158, etc.)interconnect via a data port 2156 to perform memory access andcommunicate with render output pipeline components of the processor. Asampler 2154, caches 2151, 2158 and execution units 2152A-2152B each mayhave separate memory access paths. Optionally, the texture cache 2158can also be configured as a sampler cache.

The render output pipeline 2170 may contain a rasterizer and depth testcomponent 2173 that converts vertex-based objects into an associatedpixel-based representation. The rasterizer logic may include awindower/masker unit to perform fixed function triangle and linerasterization. An associated render cache 2178 and depth cache 2179 arealso available in some embodiments. A pixel operations component 2177performs pixel-based operations on the data, though in some instances,pixel operations associated with 2D operations (e.g. bit block imagetransfers with blending) are performed by the 2D engine 2141, orsubstituted at display time by the display controller 2143 using overlaydisplay planes. A shared L3 cache 2175 may be available to all graphicscomponents, allowing the sharing of data without the use of main systemmemory.

The graphics processor media pipeline 2130 may include a media engine2137 and a video front-end 2134. Video front-end 2134 may receivepipeline commands from the command streamer 2103. The media pipeline2130 may include a separate command streamer. Video front-end 2134 mayprocess media commands before sending the command to the media engine2137. Media engine 2137 may include thread spawning functionality tospawn threads for dispatch to thread execution logic 2150 via threaddispatcher 2131.

The graphics processor 2100 may include a display engine 2140. Thisdisplay engine 2140 may be external to processor 2100 and may couplewith the graphics processor via the ring interconnect 2102, or someother interconnect bus or fabric. Display engine 2140 may include a 2Dengine 2141 and a display controller 2143. Display engine 2140 maycontain special purpose logic capable of operating independently of the3D pipeline. Display controller 2143 may couple with a display device(not shown), which may be a system integrated display device, as in alaptop computer, or an external display device attached via a displaydevice connector.

The geometry pipeline 2120 and media pipeline 2130 maybe configurable toperform operations based on multiple graphics and media programminginterfaces and are not specific to any one application programminginterface (API). A driver software for the graphics processor maytranslate API calls that are specific to a particular graphics or medialibrary into commands that can be processed by the graphics processor.Support may be provided for the Open Graphics Library (OpenGL), OpenComputing Language (OpenCL), and/or Vulkan graphics and compute API, allfrom the Khronos Group. Support may also be provided for the Direct3Dlibrary from the Microsoft Corporation. A combination of these librariesmay be supported. Support may also be provided for the Open SourceComputer Vision Library (OpenCV). A future API with a compatible 3Dpipeline would also be supported if a mapping can be made from thepipeline of the future API to the pipeline of the graphics processor.

Graphics Pipeline Programming

FIG. 22A is a block diagram illustrating a graphics processor commandformat 2200 used for programming graphics processing pipelines, such as,for example, the pipelines described herein in conjunction with FIG.16A, 17, 21. FIG. 22B is a block diagram illustrating a graphicsprocessor command sequence 2210 according to an embodiment. The solidlined boxes in FIG. 22A illustrate the components that are generallyincluded in a graphics command while the dashed lines include componentsthat are optional or that are only included in a sub-set of the graphicscommands. The exemplary graphics processor command format 2200 of FIG.22A includes data fields to identify a client 2202, a command operationcode (opcode) 2204, and data 2206 for the command A sub-opcode 2205 anda command size 2208 are also included in some commands.

Client 2202 may specify the client unit of the graphics device thatprocesses the command data. A graphics processor command parser mayexamine the client field of each command to condition the furtherprocessing of the command and route the command data to the appropriateclient unit. The graphics processor client units may include a memoryinterface unit, a render unit, a 2D unit, a 3D unit, and a media unit.Each client unit may have a corresponding processing pipeline thatprocesses the commands Once the command is received by the client unit,the client unit reads the opcode 2204 and, if present, sub-opcode 2205to determine the operation to perform. The client unit performs thecommand using information in data field 2206. For some commands anexplicit command size 2208 is expected to specify the size of thecommand. The command parser may automatically determine the size of atleast some of the commands based on the command opcode. Commands may bealigned via multiples of a double word. Other command formats can alsobe used.

The flow diagram in FIG. 22B illustrates an exemplary graphics processorcommand sequence 2210. Software or firmware of a data processing systemthat features an exemplary graphics processor may use a version of thecommand sequence shown to set up, execute, and terminate a set ofgraphics operations. A sample command sequence is shown and describedfor purposes of example only and is not limited to these specificcommands or to this command sequence. Moreover, the commands may beissued as batch of commands in a command sequence, such that thegraphics processor will process the sequence of commands in at leastpartially concurrence.

The graphics processor command sequence 2210 may begin with a pipelineflush command 2212 to cause any active graphics pipeline to complete thecurrently pending commands for the pipeline. Optionally, the 3D pipeline2222 and the media pipeline 2224 may not operate concurrently. Thepipeline flush is performed to cause the active graphics pipeline tocomplete any pending commands In response to a pipeline flush, thecommand parser for the graphics processor will pause command processinguntil the active drawing engines complete pending operations and therelevant read caches are invalidated. Optionally, any data in the rendercache that is marked ‘dirty’ can be flushed to memory. Pipeline flushcommand 2212 can be used for pipeline synchronization or before placingthe graphics processor into a low power state.

A pipeline select command 2213 may be used when a command sequencerequires the graphics processor to explicitly switch between pipelines.A pipeline select command 2213 may be required only once within anexecution context before issuing pipeline commands unless the context isto issue commands for both pipelines. A pipeline flush command 2212 maybe required immediately before a pipeline switch via the pipeline selectcommand 2213.

A pipeline control command 2214 may configure a graphics pipeline foroperation and may be used to program the 3D pipeline 2222 and the mediapipeline 2224. The pipeline control command 2214 may configure thepipeline state for the active pipeline. The pipeline control command2214 may be used for pipeline synchronization and to clear data from oneor more cache memories within the active pipeline before processing abatch of commands.

Return buffer state commands 2216 may be used to configure a set ofreturn buffers for the respective pipelines to write data. Some pipelineoperations require the allocation, selection, or configuration of one ormore return buffers into which the operations write intermediate dataduring processing. The graphics processor may also use one or morereturn buffers to store output data and to perform cross threadcommunication. The return buffer state 2216 may include selecting thesize and number of return buffers to use for a set of pipelineoperations.

The remaining commands in the command sequence differ based on theactive pipeline for operations. Based on a pipeline determination 2220,the command sequence is tailored to the 3D pipeline 2222 beginning withthe 3D pipeline state 2230 or the media pipeline 2224 beginning at themedia pipeline state 2240.

The commands to configure the 3D pipeline state 2230 include 3D statesetting commands for vertex buffer state, vertex element state, constantcolor state, depth buffer state, and other state variables that are tobe configured before 3D primitive commands are processed. The values ofthese commands are determined at least in part based on the particular3D API in use. The 3D pipeline state 2230 commands may also be able toselectively disable or bypass certain pipeline elements if thoseelements will not be used.

A 3D primitive 2232 command may be used to submit 3D primitives to beprocessed by the 3D pipeline. Commands and associated parameters thatare passed to the graphics processor via the 3D primitive 2232 commandare forwarded to the vertex fetch function in the graphics pipeline. Thevertex fetch function uses the 3D primitive 2232 command data togenerate vertex data structures. The vertex data structures are storedin one or more return buffers. The 3D primitive 2232 command may be usedto perform vertex operations on 3D primitives via vertex shaders. Toprocess vertex shaders, 3D pipeline 2222 dispatches shader executionthreads to graphics processor execution units.

The 3D pipeline 2222 may be triggered via an execute 2234 command orevent. A register may write trigger command executions. An execution maybe triggered via a ‘go’ or ‘kick’ command in the command sequence.Command execution may be triggered using a pipeline synchronizationcommand to flush the command sequence through the graphics pipeline. The3D pipeline will perform geometry processing for the 3D primitives. Onceoperations are complete, the resulting geometric objects are rasterizedand the pixel engine colors the resulting pixels. Additional commands tocontrol pixel shading and pixel back end operations may also be includedfor those operations.

The graphics processor command sequence 2210 may follow the mediapipeline 2224 path when performing media operations. In general, thespecific use and manner of programming for the media pipeline 2224depends on the media or compute operations to be performed. Specificmedia decode operations may be offloaded to the media pipeline duringmedia decode. The media pipeline can also be bypassed and media decodecan be performed in whole or in part using resources provided by one ormore general-purpose processing cores. The media pipeline may alsoinclude elements for general-purpose graphics processor unit (GPGPU)operations, where the graphics processor is used to perform SIMD vectoroperations using computational shader programs that are not explicitlyrelated to the rendering of graphics primitives.

Media pipeline 2224 may be configured in a similar manner as the 3Dpipeline 2222. A set of commands to configure the media pipeline state2240 are dispatched or placed into a command queue before the mediaobject commands 2242. Commands for the media pipeline state 2240 mayinclude data to configure the media pipeline elements that will be usedto process the media objects. This includes data to configure the videodecode and video encode logic within the media pipeline, such as encodeor decode format. Commands for the media pipeline state 2240 may alsosupport the use of one or more pointers to “indirect” state elementsthat contain a batch of state settings.

Media object commands 2242 may supply pointers to media objects forprocessing by the media pipeline. The media objects include memorybuffers containing video data to be processed. Optionally, all mediapipeline states must be valid before issuing a media object command2242. Once the pipeline state is configured and media object commands2242 are queued, the media pipeline 2224 is triggered via an executecommand 2244 or an equivalent execute event (e.g., register write).Output from media pipeline 2224 may then be post processed by operationsprovided by the 3D pipeline 2222 or the media pipeline 2224. GPGPUoperations may be configured and executed in a similar manner as mediaoperations.

Graphics Software Architecture

FIG. 23 illustrates an exemplary graphics software architecture for adata processing system 2300. Such a software architecture may include a3D graphics application 2310, an operating system 2320, and at least oneprocessor 2330. Processor 2330 may include a graphics processor 2332 andone or more general-purpose processor core(s) 2334. The processor 2330may be a variant of the processor 1402 or any other of the processorsdescribed herein. The processor 2330 may be used in place of theprocessor 1402 or any other of the processors described herein.Therefore, the disclosure of any features in combination with theprocessor 1402 or any other of the processors described herein alsodiscloses a corresponding combination with the graphics processor 2330,but is not limited to such. Moreover, the elements of FIG. 23 having thesame or similar names as the elements of any other figure hereindescribe the same elements as in the other figures, can operate orfunction in a manner similar to that, can comprise the same components,and can be linked to other entities, as those described elsewhereherein, but are not limited to such. The graphics application 2310 andoperating system 2320 are each executed in the system memory 2350 of thedata processing system.

3D graphics application 2310 may contain one or more shader programsincluding shader instructions 2312. The shader language instructions maybe in a high-level shader language, such as the High-Level ShaderLanguage (HLSL) of Direct3D, the OpenGL Shader Language (GLSL), and soforth. The application may also include executable instructions 2314 ina machine language suitable for execution by the general-purposeprocessor core 2334. The application may also include graphics objects2316 defined by vertex data.

The operating system 2320 may be a Microsoft® Windows® operating systemfrom the Microsoft Corporation, a proprietary UNIX-like operatingsystem, or an open source UNIX-like operating system using a variant ofthe Linux kernel. The operating system 2320 can support a graphics API2322 such as the Direct3D API, the OpenGL API, or the Vulkan API. Whenthe Direct3D API is in use, the operating system 2320 uses a front-endshader compiler 2324 to compile any shader instructions 2312 in HLSLinto a lower-level shader language. The compilation may be ajust-in-time (JIT) compilation or the application can perform shaderpre-compilation. High-level shaders may be compiled into low-levelshaders during the compilation of the 3D graphics application 2310. Theshader instructions 2312 may be provided in an intermediate form, suchas a version of the Standard Portable Intermediate Representation (SPIR)used by the Vulkan API.

User mode graphics driver 2326 may contain a back-end shader compiler2327 to convert the shader instructions 2312 into a hardware specificrepresentation. When the OpenGL API is in use, shader instructions 2312in the GLSL high-level language are passed to a user mode graphicsdriver 2326 for compilation. The user mode graphics driver 2326 may useoperating system kernel mode functions 2328 to communicate with a kernelmode graphics driver 2329. The kernel mode graphics driver 2329 maycommunicate with graphics processor 2332 to dispatch commands andinstructions.

IP Core Implementations

One or more aspects may be implemented by representative code stored ona machine-readable medium which represents and/or defines logic withinan integrated circuit such as a processor. For example, themachine-readable medium may include instructions which represent variouslogic within the processor. When read by a machine, the instructions maycause the machine to fabricate the logic to perform the techniquesdescribed herein. Such representations, known as “IP cores,” arereusable units of logic for an integrated circuit that may be stored ona tangible, machine-readable medium as a hardware model that describesthe structure of the integrated circuit. The hardware model may besupplied to various customers or manufacturing facilities, which loadthe hardware model on fabrication machines that manufacture theintegrated circuit. The integrated circuit may be fabricated such thatthe circuit performs operations described in association with any of theembodiments described herein.

FIG. 24A is a block diagram illustrating an IP core development system2400 that may be used to manufacture an integrated circuit to performoperations according to an embodiment. The IP core development system2400 may be used to generate modular, re-usable designs that can beincorporated into a larger design or used to construct an entireintegrated circuit (e.g., an SOC integrated circuit). A design facility2430 can generate a software simulation 2410 of an IP core design in ahigh-level programming language (e.g., C/C++). The software simulation2410 can be used to design, test, and verify the behavior of the IP coreusing a simulation model 2412. The simulation model 2412 may includefunctional, behavioral, and/or timing simulations. A register transferlevel (RTL) design 2415 can then be created or synthesized from thesimulation model 2412. The RTL design 2415 is an abstraction of thebehavior of the integrated circuit that models the flow of digitalsignals between hardware registers, including the associated logicperformed using the modeled digital signals. In addition to an RTLdesign 2415, lower-level designs at the logic level or transistor levelmay also be created, designed, or synthesized. Thus, the particulardetails of the initial design and simulation may vary.

The RTL design 2415 or equivalent may be further synthesized by thedesign facility into a hardware model 2420, which may be in a hardwaredescription language (HDL), or some other representation of physicaldesign data. The HDL may be further simulated or tested to verify the IPcore design. The IP core design can be stored for delivery to a 3^(rd)party fabrication facility 2465 using non-volatile memory 2440 (e.g.,hard disk, flash memory, or any non-volatile storage medium).Alternatively, the IP core design may be transmitted (e.g., via theInternet) over a wired connection 2450 or wireless connection 2460. Thefabrication facility 2465 may then fabricate an integrated circuit thatis based at least in part on the IP core design. The fabricatedintegrated circuit can be configured to perform operations in accordancewith at least one embodiment described herein.

FIG. 24B illustrates a cross-section side view of an integrated circuitpackage assembly 2470. The integrated circuit package assembly 2470illustrates an implementation of one or more processor or acceleratordevices as described herein. The package assembly 2470 includes multipleunits of hardware logic 2472, 2474 connected to a substrate 2480. Thelogic 2472, 2474 may be implemented at least partly in configurablelogic or fixed-functionality logic hardware, and can include one or moreportions of any of the processor core(s), graphics processor(s), orother accelerator devices described herein. Each unit of logic 2472,2474 can be implemented within a semiconductor die and coupled with thesubstrate 2480 via an interconnect structure 2473. The interconnectstructure 2473 may be configured to route electrical signals between thelogic 2472, 2474 and the substrate 2480, and can include interconnectssuch as, but not limited to bumps or pillars. The interconnect structure2473 may be configured to route electrical signals such as, for example,input/output (I/O) signals and/or power or ground signals associatedwith the operation of the logic 2472, 2474. Optionally, the substrate2480 may be an epoxy-based laminate substrate. The substrate 2480 mayalso include other suitable types of substrates. The package assembly2470 can be connected to other electrical devices via a packageinterconnect 2483. The package interconnect 2483 may be coupled to asurface of the substrate 2480 to route electrical signals to otherelectrical devices, such as a motherboard, other chipset, or multi-chipmodule.

The units of logic 2472, 2474 may be electrically coupled with a bridge2482 that is configured to route electrical signals between the logic2472, 2474. The bridge 2482 may be a dense interconnect structure thatprovides a route for electrical signals. The bridge 2482 may include abridge substrate composed of glass or a suitable semiconductor material.Electrical routing features can be formed on the bridge substrate toprovide a chip-to-chip connection between the logic 2472, 2474.

Although two units of logic 2472, 2474 and a bridge 2482 areillustrated, embodiments described herein may include more or fewerlogic units on one or more dies. The one or more dies may be connectedby zero or more bridges, as the bridge 2482 may be excluded when thelogic is included on a single die. Alternatively, multiple dies or unitsof logic can be connected by one or more bridges. Additionally, multiplelogic units, dies, and bridges can be connected together in otherpossible configurations, including three-dimensional configurations.

FIG. 24C illustrates a package assembly 2490 that includes multipleunits of hardware logic chiplets connected to a substrate 2480 (e.g.,base die). A graphics processing unit, parallel processor, and/orcompute accelerator as described herein can be composed from diversesilicon chiplets that are separately manufactured. In this context, achiplet is an at least partially packaged integrated circuit thatincludes distinct units of logic that can be assembled with otherchiplets into a larger package. A diverse set of chiplets with differentIP core logic can be assembled into a single device. Additionally thechiplets can be integrated into a base die or base chiplet using activeinterposer technology. The concepts described herein enable theinterconnection and communication between the different forms of IPwithin the GPU. IP cores can be manufactured using different processtechnologies and composed during manufacturing, which avoids thecomplexity of converging multiple IPs, especially on a large SoC withseveral flavors IPs, to the same manufacturing process. Enabling the useof multiple process technologies improves the time to market andprovides a cost-effective way to create multiple product SKUs.Additionally, the disaggregated IPs are more amenable to being powergated independently, components that are not in use on a given workloadcan be powered off, reducing overall power consumption.

The hardware logic chiplets can include special purpose hardware logicchiplets 2472, logic or I/O chiplets 2474, and/or memory chiplets 2475.The hardware logic chiplets 2472 and logic or I/O chiplets 2474 may beimplemented at least partly in configurable logic or fixed-functionalitylogic hardware and can include one or more portions of any of theprocessor core(s), graphics processor(s), parallel processors, or otheraccelerator devices described herein. The memory chiplets 2475 can beDRAM (e.g., GDDR, HBM) memory or cache (SRAM) memory.

Each chiplet can be fabricated as separate semiconductor die and coupledwith the substrate 2480 via an interconnect structure 2473. Theinterconnect structure 2473 may be configured to route electricalsignals between the various chiplets and logic within the substrate2480. The interconnect structure 2473 can include interconnects such as,but not limited to bumps or pillars. In some embodiments, theinterconnect structure 2473 may be configured to route electricalsignals such as, for example, input/output (I/O) signals and/or power orground signals associated with the operation of the logic, I/O andmemory chiplets.

The substrate 2480 may be an epoxy-based laminate substrate, however, itis not limited to that and the substrate 2480 may also include othersuitable types of substrates. The package assembly 2490 can be connectedto other electrical devices via a package interconnect 2483. The packageinterconnect 2483 may be coupled to a surface of the substrate 2480 toroute electrical signals to other electrical devices, such as amotherboard, other chipset, or multi-chip module.

A logic or I/O chiplet 2474 and a memory chiplet 2475 may beelectrically coupled via a bridge 2487 that is configured to routeelectrical signals between the logic or I/O chiplet 2474 and a memorychiplet 2475. The bridge 2487 may be a dense interconnect structure thatprovides a route for electrical signals. The bridge 2487 may include abridge substrate composed of glass or a suitable semiconductor material.Electrical routing features can be formed on the bridge substrate toprovide a chip-to-chip connection between the logic or I/O chiplet 2474and a memory chiplet 2475. The bridge 2487 may also be referred to as asilicon bridge or an interconnect bridge. For example, the bridge 2487is an Embedded Multi-die Interconnect Bridge (EMIB). Alternatively, thebridge 2487 may simply be a direct connection from one chiplet toanother chiplet.

The substrate 2480 can include hardware components for I/O 2491, cachememory 2492, and other hardware logic 2493. A fabric 2485 can beembedded in the substrate 2480 to enable communication between thevarious logic chiplets and the logic 2491, 2493 within the substrate2480. Optionally, the I/O 2491, fabric 2485, cache, bridge, and otherhardware logic 2493 can be integrated into a base die that is layered ontop of the substrate 2480.

Furthermore, a package assembly 2490 can also include a smaller orgreater number of components and chiplets that are interconnected by afabric 2485 or one or more bridges 2487. The chiplets within the packageassembly 2490 may be arranged in a 3D or 2.5D arrangement. In general,bridge structures 2487 may be used to facilitate a point to pointinterconnect between, for example, logic or I/O chiplets and memorychiplets. The fabric 2485 can be used to interconnect the various logicand/or I/O chiplets (e.g., chiplets 2472, 2474, 2491, 2493). with otherlogic and/or I/O chiplets. The cache memory 2492 within the substratecan act as a global cache for the package assembly 2490, part of adistributed global cache, or as a dedicated cache for the fabric 2485.

FIG. 24D illustrates a package assembly 2494 including interchangeablechiplets 2495, according to an embodiment. The interchangeable chiplets2495 can be assembled into standardized slots on one or more basechiplets 2496, 2498. The base chiplets 2496, 2498 can be coupled via abridge interconnect 2497, which can be similar to the other bridgeinterconnects described herein and may be, for example, an EMIB. Memorychiplets can also be connected to logic or I/O chiplets via a bridgeinterconnect. I/O and logic chiplets can communicate via an interconnectfabric. The base chiplets can each support one or more slots in astandardized format for one of logic or I/O or memory/cache.

SRAM and power delivery circuits may be fabricated into one or more ofthe base chiplets 2496, 2498, which can be fabricated using a differentprocess technology relative to the interchangeable chiplets 2495 thatare stacked on top of the base chiplets. For example, the base chiplets2496, 2498 can be fabricated using a larger process technology, whilethe interchangeable chiplets can be manufactured using a smaller processtechnology. One or more of the interchangeable chiplets 2495 may bememory (e.g., DRAM) chiplets. Different memory densities can be selectedfor the package assembly 2494 based on the power, and/or performancetargeted for the product that uses the package assembly 2494.Additionally, logic chiplets with a different number of type offunctional units can be selected at time of assembly based on the power,and/or performance targeted for the product. Additionally, chipletscontaining IP logic cores of differing types can be inserted into theinterchangeable chiplet slots, enabling hybrid processor designs thatcan mix and match different technology IP blocks.

Exemplary System on a Chip Integrated Circuit

FIG. 25-26 illustrate exemplary integrated circuits and associatedgraphics processors that may be fabricated using one or more IP cores.In addition to what is illustrated, other logic and circuits may beincluded, including additional graphics processors/cores, peripheralinterface controllers, or general-purpose processor cores. The elementsof FIG. 25-26 having the same or similar names as the elements of anyother figure herein describe the same elements as in the other figures,can operate or function in a manner similar to that, can comprise thesame components, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such.

FIG. 25 is a block diagram illustrating an exemplary system on a chipintegrated circuit 2500 that may be fabricated using one or more IPcores. Exemplary integrated circuit 2500 includes one or moreapplication processor(s) 2505 (e.g., CPUs), at least one graphicsprocessor 2510, which may be a variant of the graphics processor 1408,1508, 2510, or of any graphics processor described herein and may beused in place of any graphics processor described. Therefore, thedisclosure of any features in combination with a graphics processorherein also discloses a corresponding combination with the graphicsprocessor 2510, but is not limited to such. The integrated circuit 2500may additionally include an image processor 2515 and/or a videoprocessor 2520, any of which may be a modular IP core from the same ormultiple different design facilities. Integrated circuit 2500 mayinclude peripheral or bus logic including a USB controller 2525, UARTcontroller 2530, an SPI/SDIO controller 2535, and an I²S/I²C controller2540. Additionally, the integrated circuit can include a display device2545 coupled to one or more of a high-definition multimedia interface(HDMI) controller 2550 and a mobile industry processor interface (MIPI)display interface 2555. Storage may be provided by a flash memorysubsystem 2560 including flash memory and a flash memory controller.Memory interface may be provided via a memory controller 2565 for accessto SDRAM or SRAM memory devices. Some integrated circuits additionallyinclude an embedded security engine 2570.

FIG. 26A-26B are block diagrams illustrating exemplary graphicsprocessors for use within an SoC, according to embodiments describedherein. The graphics processors may be variants of the graphicsprocessor 1408, 1508, 2510, or any other graphics processor describedherein. The graphics processors may be used in place of the graphicsprocessor 1408, 1508, 2510, or any other of the graphics processorsdescribed herein. Therefore, the disclosure of any features incombination with the graphics processor 1408, 1508, 2510, or any otherof the graphics processors described herein also discloses acorresponding combination with the graphics processors of FIG. 26A-26B,but is not limited to such. FIG. 26A illustrates an exemplary graphicsprocessor 2610 of a system on a chip integrated circuit that may befabricated using one or more IP cores, according to an embodiment. FIG.26B illustrates an additional exemplary graphics processor 2640 of asystem on a chip integrated circuit that may be fabricated using one ormore IP cores, according to an embodiment. Graphics processor 2610 ofFIG. 26A is an example of a low power graphics processor core. Graphicsprocessor 2640 of FIG. 26B is an example of a higher performancegraphics processor core. For example, each of the graphics processors2610, 2640 can be a variant of the graphics processor 2510 of FIG. 25,as mentioned at the outset of this paragraph.

As shown in FIG. 26A, graphics processor 2610 includes a vertexprocessor 2605 and one or more fragment processor(s) 2615A-2615N (e.g.,2615A, 2615B, 2615C, 2615D, through 2615N-1, and 2615N). Graphicsprocessor 2610 can execute different shader programs via separate logic,such that the vertex processor 2605 is optimized to execute operationsfor vertex shader programs, while the one or more fragment processor(s)2615A-2615N execute fragment (e.g., pixel) shading operations forfragment or pixel shader programs. The vertex processor 2605 performsthe vertex processing stage of the 3D graphics pipeline and generatesprimitives and vertex data. The fragment processor(s) 2615A-2615N usethe primitive and vertex data generated by the vertex processor 2605 toproduce a framebuffer that is displayed on a display device. Thefragment processor(s) 2615A-2615N may be optimized to execute fragmentshader programs as provided for in the OpenGL API, which may be used toperform similar operations as a pixel shader program as provided for inthe Direct 3D API.

Graphics processor 2610 additionally includes one or more memorymanagement units (MMUs) 2620A-2620B, cache(s) 2625A-2625B, and circuitinterconnect(s) 2630A-2630B. The one or more MMU(s) 2620A-2620B providefor virtual to physical address mapping for the graphics processor 2610,including for the vertex processor 2605 and/or fragment processor(s)2615A-2615N, which may reference vertex or image/texture data stored inmemory, in addition to vertex or image/texture data stored in the one ormore cache(s) 2625A-2625B. The one or more MMU(s) 2620A-2620B may besynchronized with other MMUs within the system, including one or moreMMUs associated with the one or more application processor(s) 2505,image processor 2515, and/or video processor 2520 of FIG. 25, such thateach processor 2505-2520 can participate in a shared or unified virtualmemory system. Components of graphics processor 2610 may correspond withcomponents of other graphics processors described herein. The one ormore MMU(s) 2620A-2620B may correspond with MMU 245 of FIG. 2C. Vertexprocessor 2605 and fragment processor 2615A-2615N may correspond withgraphics multiprocessor 234. The one or more circuit interconnect(s)2630A-2630B enable graphics processor 2610 to interface with other IPcores within the SoC, either via an internal bus of the SoC or via adirect connection, according to embodiments. The one or more circuitinterconnect(s) 2630A-2630B may correspond with the data crossbar 240 ofFIG. 2C. Further correspondence may be found between analogouscomponents of the graphics processor 2610 and the various graphicsprocessor architectures described herein.

As shown FIG. 26B, graphics processor 2640 includes the one or moreMMU(s) 2620A-2620B, cache(s) 2625A-2625B, and circuit interconnect(s)2630A-2630B of the graphics processor 2610 of FIG. 26A. Graphicsprocessor 2640 includes one or more shader cores 2655A-2655N (e.g.,2655A, 2655B, 2655C, 2655D, 2655E, 2655F, through 2655N-1, and 2655N),which provides for a unified shader core architecture in which a singlecore or type or core can execute all types of programmable shader code,including shader program code to implement vertex shaders, fragmentshaders, and/or compute shaders. The exact number of shader corespresent can vary among embodiments and implementations. Additionally,graphics processor 2640 includes an inter-core task manager 2645, whichacts as a thread dispatcher to dispatch execution threads to one or moreshader cores 2655A-2655N and a tiling unit 2658 to accelerate tilingoperations for tile-based rendering, in which rendering operations for ascene are subdivided in image space, for example to exploit localspatial coherence within a scene or to optimize use of internal caches.Shader cores 2655A-2655N may correspond with, for example, graphicsmultiprocessor 234 as in FIG. 2D, or graphics multiprocessors 325, 350of FIGS. 3A and 3B respectively, or multi-core group 365A of FIG. 3C.

Multiple Tile Architecture for Graphics Operations

In some embodiments, an apparatus, system, or process provides for oneor more of:

(1) Tile Connectivity Enhancements for a Multi-Tile GPU;

(2) Asymmetrical Multi-Tile GPU Architecture; and

(3) Dynamic Exclusive Assignment of Fixed Functions to Cores.

A multi-tile GPU includes multiple processor tiles, as illustrated in,for example, FIGS. 27A-30 and 32. In some embodiments, the multipleprocessor tiles of a multi-tile processor may be combined with 3Dstacking in the fabrication of a device. The multiple processor tiles ina multi-tile processor may be fabricated using multiple differentprocesses. The multiple processor tiles may include various types oftiles having different functions and characteristics, wherein the typesof tiles may include, but are not limited to, power regulators andsystem/IO tiles. The multiple processor tiles in a multi-tile processormay communicate with each other, including communication via a packetnetwork on a chip protocol.

In some embodiments, the apparatus, system, or process includes thefollowing:

(1) Tile Connectivity Enhancements for Multi-Tile GPU

There are numerous issues in determining how to disaggregate a GPU intomultiple processor tiles. A major concern is the connectivity betweenthe multiple processor tiles and the resulting power and physical costs.

For example, fully powering each tile in a GPU during operation mayresult in excessive power consumption, but there is can also be a costin attempting to address the power consumption separately for each tile.

Further, while the inclusion of a large number of tiles in a GPU canprovide significant benefits, the construction of such a GPUarchitecture increases in connection complexity with the addition ofeach tile, as well increasing the overhead cost required to providecommunications between such tiles.

FIG. 27A is an illustration tile connectivity in a multi-tile GPUutilizing serial or parallel links in a die, according to someembodiments. As illustrated in FIG. 27A, a multi-tile GPU 2700 mayinclude multiple processor tiles 2710, which are shown as Tile-0 throughTile-7. While for simplicity of illustration the tiles 2710 are shown ashaving uniform size and shape in FIGS. 27A-28, the tiles may be ofvarying size, shape, construction, and usage, such as illustrated inFIGS. 29, 30, and 32.

In some embodiments, the tiles 2710 are installed on one or more dies2705, the one or more dies including serial or parallel links 2720 toenable connection between the tiles 2710 in a fabricated unit. In someembodiments, the use of the serial or parallel links includesapplication of signal compression to reduce the overhead cost involvedin separating the GPU 2700 into multiple tiles 2710.

FIG. 27B is an illustration of tile connectivity in a multi-tile GPUutilizing architectural sharing of physical pins or wires between tiles,according to some embodiments. As illustrated in FIG. 27B, a multi-tileGPU 2700 may again include multiple tiles 2710 Tile-0 through Tile-7,the tiles 2710 being installed on one or more dies 2705. In someembodiments, the GPU 2700 includes one or more shared pins or wires 2730between tiles, such as between adjacent tiles, to reduce the cost andcomplexity of devices fabrication, and to potentially reduce the overallphysical size of the multi-tile GPU 2700. In some embodiments, the GPU2700 may be designed to maximize the sharing of pins or wires in theplacement of the multiple tiles 2710.

For example, Tile-4 and Tile-5 in FIG. 27B may be placed on the one ormore dies 2705 in such a manner that at least one pin or wires is sharedbetween such adjacent tiles. For example, a particular element that canbe shared (such as a common signal or ground connection) may be utilizedto determine how Tile-4 and Tile-5 (and the other tiles) are installedin the one or more dies 2705.

FIG. 28 is an illustration of tile connectivity in a multi-tile GPUutilizing a tile sub-cluster architecture, according to someembodiments. As illustrated in FIG. 28, a multi-tile GPU 2200 may againinclude multiple processor tiles 2810 Tile-0 through Tile-7, the tiles2810 being installed on one or more dies 2805. In some embodiments, thetiles may be gathered into one or more sub-clusters, wherein theimposition of the sub-cluster architecture may enable a scaling effectfor a GPU, such as allowing for simplification and improved efficiencyby allowing certain related tiles to share certain facilities, signals,or services.

For example, as illustrated in FIG. 28, some or all of the tiles 2810 ofthe GPU 2800 may be combined into sub-clusters, each sub-clusterincluding a sub-set of the multiple tiles of the multi-tile GPU. Thesub-clusters may be of varying sizes (number of tiles) and may includediffering types of tiles, depending on the nature of the tiles and theGPU. The sub-clusters in the example include a first sub-cluster oftiles 2840 including Tile-6 and Tile-7, and a second sub-cluster oftiles 2845 including Tile-2, Tile-3, Tile-4, and Tile-5. In thisparticular example, Tile-0 and Tile-1 are not included in a sub-cluster.

In some embodiments, the GPU 2800 may include one or more features toenable the clustering of tiles, wherein the clustering features 2850 mayinclude, but are not limited to use of one or more of the following toprovide coupling for the sub-clusters:

-   -   An interposer die,    -   A memory die, or    -   A 3D stacked memory.

(2) Asymmetrical Multi-Tile GPU Architecture

In conventional architectures, a multi-tile GPU is constructed ofuniform tiles. Conventional architectures focus on symmetric tiles forreasons such as simplicity and reduced cost of fabrication.

However, asymmetric tiles can be used to tune an SoC for specific usemodels, and can be a key part of die recovery plans in which asymmetricchips may be created from defective elements that are generated in themanufacturing process. For example, tensor processing units can bedecoupled from vector processing units, or rasterization/textureprocessing units can be decoupled from processors.

In some embodiments of an apparatus, system, or process, a GPU withmultiple processor tiles (chiplets) may include tiles of differentsizes, which may be applied to generate a GPU having specificcharacteristics or usages.

Non-uniform tiles may include, but are not limited to, the following

(i) Size differences—In some embodiments, tiles may be of varying size.For example, large tile may include more processing resources thansmaller tiles.

(ii) Hardware units: Certain tiles may include systolic array cores,while other include other core architectures,

(iii) Valid Instruction Set Architecture (ISA)—Different tiles may beconstructed to support different ISA. For example, some tiles maysupport, FP64 (64-bit floating-point format, also referred todouble-precision floating-point format), while other tiles may supportFP32-only (32-bit floating-point format, also referred tosingle-precision floating-point format).

(iv) Fusing off resources—Some tiles may include a portion that has beenfused off and is not available, such as for die recovery (in case of aportion of the tile being defective) or to provide a particular cachesize, frequency, or other feature.

FIG. 29 is an illustration of asymmetric tile construction for amulti-tile GPU, according to some embodiments. As illustrated, amulti-tile GPU 2900 includes multiple processor tiles 2920. In someembodiments of an apparatus, system, or process, the GPU 2910 includeswith multiple tiles of different size and shape as required orconvenient for a particular implementation, which may be applied togenerate a GPU having specific characteristics or usages.

For example, of the tiles 2920, Tile-0 and Tile-1 may be of a largersize, while Tile-5 is of a smaller size. Further, Tile-0 and Tile-1 mayhave a square shape, while Tile-2 and Tile-5 have a rectangular,non-square shapes. It is note that, while square or rectangular shapesmay be most common and generally useful shapes, embodiments are notlimited to such shapes. For example, Tile-3 and Tile-4 have triangularshapes, which be useful for certain purposes.

Further, one or more tiles may include a portion that has been fusedoff, such as the illustrated Tile-6. The fusing of a portion of a tilemay occur with the generation of a tile having a defective portion toallow the recovery of such tile, However, the fusing may also beimplemented purposely to generate certain tiles having specificcharacteristics.

FIG. 30 is an illustration of asymmetrical multi-tile architecture,according to some embodiments. As illustrated, a multi-tile GPU 3000includes multiple tiles, wherein each tile may provide one or moredifferent characteristics for a particular GPU architecture. In someembodiments of an apparatus, system, or process, the GPU 3000 mayinclude tiles supporting different ISAs, such as a tile 3010 supportingFP64 and tiles 3020 and 3025 supporting FP32 only.

In some embodiments, the tiles be designed to provide differentperformance characteristics and power costs to allow for selection of aparticular tile for processing as appropriate for a particular workload.For example, tile 3030 may include a fast, high power compute core,while tile 3035 may including a slower, lower power compute core 3035,allowing high priority workloads to be assigned to tile 3030 and lowerpriority workloads to be assigned to tile 3035, thus allowing for atradeoff of performance and power. The different in power andperformance tradeoff may include a difference in frequency of operationfor each core.

Further, certain cores may vary in supported hardware processing,allowing for, in an example, tensor processing units in tile 3040 to bedecoupled from vector processing units in tile 3045. Other specialtyfunctions may be supported by one or more tiles, such as tile 3050.

FIG. 31 is a flow chart for a process for selecting and fabricatingtiles for a multi-tile GPU, according to some embodiments. In someembodiments, a process includes identifying requirements for multipleoperations of a GPU 3000. The operations may include multiple differenttypes of processing, including processing that may requirement higher orlower performance operation, or may require certain specializedelements.

In some embodiments, a fabrication process for the GPU may include tilefabrication for the GPU 3105. In some embodiments, the tile fabricationincludes fabrication of tiles based at least in part on the identifiedrequirements for the GPU, which may include manufacturing multiple tilesof multiple different sizes and operational characteristics according tothe GPU requirements 3110.

The fabrication process further includes testing of manufactured tiles3120, which may include operations to recover certain defective tiles.In some embodiments, if the testing identifies tiles with defectiveportions 3120, there may be a determination whether the defective tileshave sufficient usable elements to utilize in a GPU. 3125. If not, thetiles are rejected 3130. However, if the tiles have sufficient usableelements, the process may proceed with fusing the defective portion ofthe tiles 3155. The fused tiles may then be included with othermanufactured tiles, with the GPU fabrication process continuing with themultiple manufactured tiles 3140.

It is noted that use of fusing is not limited to tiles with defectiveportions, In some embodiments, the manufacture of tiles may includefusing certain portions of tiles to achieve certain desiredcharacteristics for the tiles in the GPU.

(3) Dynamic Exclusive Assignment of Fixed Functions to Cores

In some embodiments, a GPU that is manufactured with multiple differenttiles, such as illustrated in FIGS. 29-31, may include varyingprocessing cores and fixed function units among the generated tiles. Insome embodiments, deployment flexibility for the GPU may be provided bymixing and matching resource tradeoffs to provide certain optimal powerand performance characteristics to direct to certain types ofprocessing. This may also be utilized to enable symmetric or asymmetricISA support for processing, as required.

For example, a particular fixed function unit may provide fastperformance but is expensive in terms of power to utilize, which anotherfixed function unit may be functional but slower in operation, whileconsuming less power Other fixed function units may have othercharacteristics that may affect selection of units. In some embodiments,a system may assign any or all of the multiple fixed function units to aparticular processing core tile depending on the particular needs, suchas, in one example, depending on particular shader program requirements.

FIG. 32 is an illustration of an apparatus or system for dynamicexclusive assignment of cores to fixed function units in a GPU,according to some embodiments. In a particular embodiment, a multi-tileGPU 3210 includes a large processing core tile 3220, wherein such coretile may provide high performance operation, but may requirement highpower consumption. The GPU 3210 may further include a small processingcore tile 3225, wherein such core tile may provide lower performanceoperation, but at a lower power cost.

Further, the GPU may include multiple fixed function units to performcertain processing functions, such as Fixed Function-1 (FF-1) 3230 andFixed Function-2 (FF-2) 3225. The fixed function units may also includedifference in performance, such as FF-1 being fast but expensive tooperate in terms of power, and FF-2 being functional but slower, whilerequiring less power consumption. It is noted that there may be anynumber of other tiles 3250 in the GPU for different purposes, which arenot illustrated in FIG. 32.

In some embodiments, the system may exclusively assign either, both, ornone of the fixed function units to each of the core tiles 3220 and3225, depending on the particular processing requirements, such asshader program requirements. The mixed characteristics of the core tilesand the fixed function may be mixed and matched to provide a correctbalance of, for example, performance and power consumption to supportone or more processing tasks. In this manner, the multi-tile GPU canprovide more flexible performance to dynamically match the particularprocessing tasks assigned to such GPU.

FIG. 33 is an illustration of a process for dynamic exclusive assignmentof cores to fixed function units in a GPU, according to someembodiments. In a particular embodiment, certain processing for one ormore applications is received for a multi-tile GPU 3300, the GPUincluding multiple processing core tiles and fixed function tiles withdifferent performance characteristics. In some embodiments, the processincludes analyzing the processing requirements for the one or moreapplications 3305, and determined preferred assignment of the processingcore tiles and fixed function tiles to meet the processing requirements3310.

In some embodiments, the process then includes providing dynamicexclusive assignment of one or more fixed function units to one or morecore tiles according to the determined preferred assignment 3315. Insome embodiments, the dynamic assignment of the fixed function tiles tothe core tiles may be modified as the processing requirements for theGPU change over time.

In some embodiments, an apparatus includes a multi-tile architecture forgraphics operations including a multi-tile graphics processor, themulti-tile processor including one or more dies; a plurality ofprocessor tiles installed on the one or more dies; and a structure tointerconnect the plurality or processor tiles on the one or more dies,the structure to enable communications between processor tiles of theplurality of processor tiles.

In some embodiments, the structure includes parallel or serial links onthe one or more dies to interconnect the plurality of processor tiles.

In some embodiments, the parallel or serial links on the one or moredies enable signal compression for the communications between theplurality of processor tiles.

In some embodiments, the structure includes one or more shared wires orpins between processor tiles of the plurality of processor tiles,including at least one wire or pin shared between a first processor tileand a second processor tile, the first processor tile and the secondprocessor tile being adjacent tiles.

In some embodiments, the at least one wire or pin shared between thefirst processor tile and the second processor tile is connected with ashared element for the first processor tile and the second processortile.

In some embodiments, the structure includes a tile sub-clusterarchitecture, the architecture including one or more sub-clusters ofprocessor tiles, each sub-cluster including a subset of the plurality ofprocessor tiles.

In some embodiments, the apparatus further includes one or more featuresto enable clustering of processor tiles.

In some embodiments, the one or more features include one or more of aninterposer die, a memory die, or 3D stacked memory.

In some embodiments, the one or more sub-clusters include a firstsub-cluster and a second sub-cluster, the first sub-cluster and thesecond sub-cluster being different in one or more of a number ofprocessor tiles in each sub-cluster or types of processor tiles in eachsub-cluster.

In some embodiments, a method includes fabricating a multi-tile graphicsprocessor, wherein fabricating the multi-tile graphics processorincluding providing: one or more dies; a plurality of processor tilesinstalled on the one or more dies; and a structure to interconnect theplurality processor tiles on the one or more dies; wherein the structureis to enable communications between processor tiles of the plurality ofprocessor tiles.

In some embodiments, the structure includes parallel or serial links onthe one or more dies to interconnect the plurality of processor tiles,wherein the parallel or serial links on the one or more dies enablesignal compression for the communications between the plurality ofprocessor tiles.

In some embodiments, the structure includes one or more shared wires orpins between processor tiles of the plurality of processor tiles,including at least one wire or pin shared between a first processor tileand a second processor tile, the first processor tile and the secondprocessor tile being adjacent tiles.

In some embodiments, the structure includes a tile sub-clusterarchitecture, the architecture including one or more sub-clusters ofprocessor tiles, each sub-cluster including a subset of the plurality ofprocessor tiles.

In some embodiments, fabricating the multi-tile graphics processorfurther includes providing one or more features to enable clustering ofprocessor tiles.

In some embodiments, the one or more features include one or more of aninterposer die, a memory die, or 3D stacked memory.

In some embodiments, the one or more sub-clusters include a firstsub-cluster and a second sub-cluster, the first sub-cluster and thesecond sub-cluster being different in one or more of a number ofprocessor tiles in each sub-cluster or types of processor tiles in eachsub-cluster.

In some embodiments, a system includes one or more processors includinga graphics processor; and a memory to hold data for processing; whereinthe graphics processor includes one or more dies; a plurality ofprocessor tiles installed on the die, and a structure to interconnectthe plurality of processor tiles on the one or more dies, the structureto enable communications between processor tiles of the plurality ofprocessor tiles.

In some embodiments, the structure includes parallel or serial links onthe one or more dies to interconnect the plurality of processor tiles.

In some embodiments, the structure includes one or more shared wires orpins between processor tiles of the plurality of processor tiles,including at least one wire or pin shared between a first processor tileand a second processor tile, the first processor tile and the secondprocessor tile being adjacent tiles.

In some embodiments, the structure includes a tile sub-clusterarchitecture, the architecture including one or more sub-clusters ofprocessor tiles, each sub-cluster including a subset of the plurality ofprocessor tiles.

In some embodiments, an apparatus includes a multi-tile graphicsprocessor, the multi-tile processor including a plurality of asymmetricprocessor tiles; wherein the plurality of asymmetric processor tilesinclude processor tiles that differ in one or more characteristics; andwherein the plurality of asymmetric processor tiles are selected toprovide a graphics processor having specific characteristics or usages.

In some embodiments, the one or more characteristics include one or moreof: size; shape; function; performance; power consumption; type ofhardware units; and instruction set architecture.

In some embodiments, the plurality of asymmetric processor tiles includeone or more tiles having a portion that is fused off.

In some embodiments, a fused off portion of a first processor tile is adefective portion of the first processor tile.

In some embodiments, a fused off portion of a second processor tile isfused off to achieve a certain set of characteristics for the graphicsprocessor

In some embodiments, one or more non-transitory computer-readablestorage mediums having stored thereon executable computer programinstructions that, when executed by one or more processors, cause theone or more processors to perform operations including receivingprocessing for one or more applications for a multi-tile graphicsprocessor, the graphics processor including one or more processing coretiles and one or more fixed function tiles; analyzing processingrequirements for the one or more applications; determining preferredassignment of the one or more processing core tiles and fixed functiontiles to meet the processing requirements; and providing dynamicexclusive assignment of the one or more fixed function units to the oneor more processing core tiles according to the determined preferredassignment.

In some embodiments, the dynamic assignment of the fixed function tilesto the processing core tiles may be modified as the processingrequirements for the GPU change over time.

In some embodiments, the dynamic assignment including dynamicallyassigning at least a first fixed function tile of the one or more fixedfunction tiles exclusively to a first processing core tile of the one ormore processing core tiles.

In some embodiments, the dynamic assignment to the first processing coretile is selected based at least in part on processing requirements forthe first processing core tile.

In some embodiments, the exclusive assignment of fixed functions in themulti-tile graphics processor is modified dynamically.

In some embodiments, the one or more fixed function tiles include atleast a first fixed function tile and a second fixed function tile, thefirst and second fixed function tiles having different performancecharacteristics.

In some embodiments, the one or more processing tiles include at least afirst processing core tile and a second processing core tile, the firstand second processing core tiles having different characteristics.

In some embodiments, the first processing core tile provides higherperformance than the second processing core tile.

The foregoing description and drawings are to be regarded in anillustrative rather than a restrictive sense. Persons skilled in the artwill understand that various modifications and changes may be made tothe embodiments described herein without departing from the broaderspirit and scope of the embodiments as set forth in the appended claims.

In the description above, for the purposes of explanation, numerousspecific details are set forth in order to provide a thoroughunderstanding of the described embodiments. It will be apparent,however, to one skilled in the art that embodiments may be practicedwithout some of these specific details. In other instances, well-knownstructures and devices are shown in block diagram form. There may beintermediate structure between illustrated components. The componentsdescribed or illustrated herein may have additional inputs or outputsthat are not illustrated or described.

Various embodiments may include various processes. These processes maybe performed by hardware components or may be embodied in computerprogram or machine-executable instructions, which may be used to cause ageneral-purpose or special-purpose processor or logic circuitsprogrammed with the instructions to perform the processes.Alternatively, the processes may be performed by a combination ofhardware and software.

Portions of various embodiments may be provided as a computer programproduct, which may include a computer-readable medium having storedthereon computer program instructions, which may be used to program acomputer (or other electronic devices) for execution by one or moreprocessors to perform a process according to certain embodiments. Thecomputer-readable medium may include, but is not limited to, magneticdisks, optical disks, read-only memory (ROM), random access memory(RAM), erasable programmable read-only memory (EPROM),electrically-erasable programmable read-only memory (EEPROM), magneticor optical cards, flash memory, or other type of computer-readablemedium suitable for storing electronic instructions. Moreover,embodiments may also be downloaded as a computer program product,wherein the program may be transferred from a remote computer to arequesting computer. In some embodiments, a non-transitorycomputer-readable storage medium has stored thereon data representingsequences of instructions that, when executed by a processor, cause theprocessor to perform certain operations.

Many of the methods are described in their most basic form, butprocesses can be added to or deleted from any of the methods andinformation can be added or subtracted from any of the describedmessages without departing from the basic scope of the presentembodiments. It will be apparent to those skilled in the art that manyfurther modifications and adaptations can be made. The particularembodiments are not provided to limit the concept but to illustrate it.The scope of the embodiments is not to be determined by the specificexamples provided above but only by the claims below.

If it is said that an element “A” is coupled to or with element “B,”element A may be directly coupled to element B or be indirectly coupledthrough, for example, element C. When the specification or claims statethat a component, feature, structure, process, or characteristic A“causes” a component, feature, structure, process, or characteristic B,it means that “A” is at least a partial cause of “B” but that there mayalso be at least one other component, feature, structure, process, orcharacteristic that assists in causing “B.” If the specificationindicates that a component, feature, structure, process, orcharacteristic “may”, “might”, or “could” be included, that particularcomponent, feature, structure, process, or characteristic is notrequired to be included. If the specification or claim refers to “a” or“an” element, this does not mean there is only one of the describedelements.

An embodiment is an implementation or example. Reference in thespecification to “an embodiment,” “one embodiment,” “some embodiments,”or “other embodiments” means that a particular feature, structure, orcharacteristic described in connection with the embodiments is includedin at least some embodiments, but not necessarily all embodiments. Thevarious appearances of “an embodiment,” “one embodiment,” or “someembodiments” are not necessarily all referring to the same embodiments.It should be appreciated that in the foregoing description of exemplaryembodiments, various features are sometimes grouped together in a singleembodiment, figure, or description thereof for the purpose ofstreamlining the disclosure and aiding in the understanding of one ormore of the various novel aspects. This method of disclosure, however,is not to be interpreted as reflecting an intention that the claimedembodiments requires more features than are expressly recited in eachclaim. Rather, as the following claims reflect, novel aspects lie inless than all features of a single foregoing disclosed embodiment. Thus,the claims are hereby expressly incorporated into this description, witheach claim standing on its own as a separate embodiment.

What is claimed is:
 1. An apparatus comprising: a multi-tilearchitecture for graphics operations including a multi-tile graphicsprocessor, the multi-tile processor including: one or more dies; aplurality of processor tiles installed on the one or more dies; and astructure to interconnect the plurality or processor tiles on the one ormore dies; wherein the structure is to enable communications betweenprocessor tiles of the plurality of processor tiles.
 2. The apparatus ofclaim 1, wherein the structure includes parallel or serial links on theone or more dies to interconnect the plurality of processor tiles. 3.The apparatus of claim 2, wherein the parallel or serial links on theone or more dies enable signal compression for the communicationsbetween the plurality of processor tiles.
 4. The apparatus of claim 1,wherein the structure includes one or more shared wires or pins betweenprocessor tiles of the plurality of processor tiles, including at leastone wire or pin shared between a first processor tile and a secondprocessor tile, the first processor tile and the second processor tilebeing adjacent tiles.
 5. The apparatus of claim 4, wherein the at leastone wire or pin shared between the first processor tile and the secondprocessor tile is connected with a shared element for the firstprocessor tile and the second processor tile.
 6. The apparatus of claim1, wherein the structure includes a tile sub-cluster architecture, thearchitecture including one or more sub-clusters of processor tiles, eachsub-cluster including a subset of the plurality of processor tiles. 7.The apparatus of claim 6, wherein the apparatus further includes one ormore features to enable clustering of processor tiles.
 8. The apparatusof claim 7, wherein the one or more features include one or more of aninterposer die, a memory die, or 3D stacked memory.
 9. The apparatus ofclaim 6, wherein the one or more sub-clusters include a firstsub-cluster and a second sub-cluster, the first sub-cluster and thesecond sub-cluster being different in one or more of a number ofprocessor tiles in each sub-cluster or types of processor tiles in eachsub-cluster.
 10. A method comprising: fabricating a multi-tile graphicsprocessor, wherein fabricating the multi-tile graphics processorincluding providing: one or more dies; a plurality of processor tilesinstalled on the one or more dies; and a structure to interconnect theplurality processor tiles on the one or more dies; wherein the structureis to enable communications between processor tiles of the plurality ofprocessor tiles.
 11. The method of claim 10, wherein the structureincludes parallel or serial links on the one or more dies tointerconnect the plurality of processor tiles, wherein the parallel orserial links on the one or more dies enable signal compression for thecommunications between the plurality of processor tiles.
 12. The methodof claim 10, wherein the structure includes one or more shared wires orpins between processor tiles of the plurality of processor tiles,including at least one wire or pin shared between a first processor tileand a second processor tile, the first processor tile and the secondprocessor tile being adjacent tiles.
 13. The method of claim 10, whereinthe structure includes a tile sub-cluster architecture, the architectureincluding one or more sub-clusters of processor tiles, each sub-clusterincluding a subset of the plurality of processor tiles.
 14. The methodof claim 13, wherein fabricating the multi-tile graphics processorfurther includes providing one or more features to enable clustering ofprocessor tiles.
 15. The method of claim 14, wherein the one or morefeatures include one or more of an interposer die, a memory die, or 3Dstacked memory.
 16. The method of claim 13, wherein the one or moresub-clusters include a first sub-cluster and a second sub-cluster, thefirst sub-cluster and the second sub-cluster being different in one ormore of a number of processor tiles in each sub-cluster or types ofprocessor tiles in each sub-cluster.
 17. A system comprising: one ormore processors including a multi-tile graphics processor; and a memoryto hold data for processing; wherein the multi-tile graphics processorincludes: one or more dies; a plurality of processor tiles installed onthe one or more dies, and a structure to interconnect the plurality ofprocessor tiles on the one or more dies, the structure to enablecommunications between processor tiles of the plurality of processortiles.
 18. The system of claim 17, wherein the structure includesparallel or serial links on the one or more dies to interconnect theplurality of processor tiles.
 19. The system of claim 17, wherein thestructure includes one or more shared wires or pins between processortiles of the plurality of processor tiles, including at least one wireor pin shared between a first processor tile and a second processortile, the first processor tile and the second processor tile beingadjacent tiles.
 20. The system of claim 17, wherein the structureincludes a tile sub-cluster architecture, the architecture including oneor more sub-clusters of processor tiles, each sub-cluster including asubset of the plurality of processor tiles.